<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE BangPatterns, CPP, DeriveFunctor, MagicHash, RecordWildCards #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# OPTIONS_GHC -optc-DNON_POSIX_SOURCE #-}</span><span>
</span><span id="line-3"></span><span class="hs-comment">--</span><span>
</span><span id="line-4"></span><span class="hs-comment">--  (c) The University of Glasgow 2002-2006</span><span>
</span><span id="line-5"></span><span class="hs-comment">--</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span class="hs-comment">-- | Bytecode assembler and linker</span><span>
</span><span id="line-8"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.ByteCode.Asm</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-9"></span><span>        </span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleBCOs"><span class="hs-identifier">assembleBCOs</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleOneBCO"><span class="hs-identifier">assembleOneBCO</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-10"></span><span>
</span><span id="line-11"></span><span>        </span><span class="annot"><a href="GHC.ByteCode.Asm.html#bcoFreeNames"><span class="hs-identifier">bcoFreeNames</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-12"></span><span>        </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#SizedSeq"><span class="hs-identifier">SizedSeq</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#sizeSS"><span class="hs-identifier">sizeSS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#ssElts"><span class="hs-identifier">ssElts</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-13"></span><span>        </span><span class="annot"><a href="GHC.ByteCode.Asm.html#iNTERP_STACK_CHECK_THRESH"><span class="hs-identifier">iNTERP_STACK_CHECK_THRESH</span></a></span><span>
</span><span id="line-14"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">

#include &quot;HsVersions.h&quot;
</span><span>
</span><span id="line-18"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Prelude.html"><span class="hs-identifier">GHC.Prelude</span></a></span><span>
</span><span id="line-19"></span><span>
</span><span id="line-20"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.ByteCode.Instr.html"><span class="hs-identifier">GHC.ByteCode.Instr</span></a></span><span>
</span><span id="line-21"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.ByteCode.InfoTable.html"><span class="hs-identifier">GHC.ByteCode.InfoTable</span></a></span><span>
</span><span id="line-22"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html"><span class="hs-identifier">GHC.ByteCode.Types</span></a></span><span>
</span><span id="line-23"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghci/src/GHCi.RemoteTypes.html#"><span class="hs-identifier">GHCi.RemoteTypes</span></a></span><span>
</span><span id="line-24"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Runtime.Interpreter.html"><span class="hs-identifier">GHC.Runtime.Interpreter</span></a></span><span>
</span><span id="line-25"></span><span>
</span><span id="line-26"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Driver.Types.html"><span class="hs-identifier">GHC.Driver.Types</span></a></span><span>
</span><span id="line-27"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Name.html"><span class="hs-identifier">GHC.Types.Name</span></a></span><span>
</span><span id="line-28"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Name.Set.html"><span class="hs-identifier">GHC.Types.Name.Set</span></a></span><span>
</span><span id="line-29"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Literal.html"><span class="hs-identifier">GHC.Types.Literal</span></a></span><span>
</span><span id="line-30"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html"><span class="hs-identifier">GHC.Core.TyCon</span></a></span><span>
</span><span id="line-31"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html"><span class="hs-identifier">GHC.Data.FastString</span></a></span><span>
</span><span id="line-32"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.StgToCmm.Layout.html"><span class="hs-identifier">GHC.StgToCmm.Layout</span></a></span><span>     </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.StgToCmm.ArgRep.html#ArgRep"><span class="hs-identifier">ArgRep</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-33"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Runtime.Heap.Layout.html"><span class="hs-identifier">GHC.Runtime.Heap.Layout</span></a></span><span>
</span><span id="line-34"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Driver.Session.html"><span class="hs-identifier">GHC.Driver.Session</span></a></span><span>
</span><span id="line-35"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Utils.Outputable.html"><span class="hs-identifier">GHC.Utils.Outputable</span></a></span><span>
</span><span id="line-36"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#"><span class="hs-identifier">GHC.Platform</span></a></span><span>
</span><span id="line-37"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Utils.Misc.html"><span class="hs-identifier">GHC.Utils.Misc</span></a></span><span>
</span><span id="line-38"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Unique.html"><span class="hs-identifier">GHC.Types.Unique</span></a></span><span>
</span><span id="line-39"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Unique.DSet.html"><span class="hs-identifier">GHC.Types.Unique.DSet</span></a></span><span>
</span><span id="line-40"></span><span>
</span><span id="line-41"></span><span class="hs-comment">-- From iserv</span><span>
</span><span id="line-42"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#"><span class="hs-identifier">SizedSeq</span></a></span><span>
</span><span id="line-43"></span><span>
</span><span id="line-44"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span>
</span><span id="line-45"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.ST.html#"><span class="hs-identifier">Control.Monad.ST</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier">runST</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-46"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Class.html#"><span class="hs-identifier">Control.Monad.Trans.Class</span></a></span><span>
</span><span id="line-47"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.State.Strict</span></a></span><span>
</span><span id="line-48"></span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.MArray.html#"><span class="hs-identifier">Data.Array.MArray</span></a></span><span>
</span><span id="line-50"></span><span>
</span><span id="line-51"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Unboxed.html#"><span class="hs-identifier">Data.Array.Unboxed</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Array</span></span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#"><span class="hs-identifier">Data.Array.Base</span></a></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#UArray"><span class="hs-identifier">UArray</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-53"></span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Unsafe.html#"><span class="hs-identifier">Data.Array.Unsafe</span></a></span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier">castSTUArray</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-55"></span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.html#"><span class="hs-identifier">Foreign</span></a></span><span>
</span><span id="line-57"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#"><span class="hs-identifier">Data.Char</span></a></span><span>        </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#ord"><span class="hs-identifier">ord</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-58"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span>        </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.OldList.html#genericLength"><span class="hs-identifier">genericLength</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.html#"><span class="hs-identifier">Data.Map</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Map.Internal.html#Map"><span class="hs-identifier">Map</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-60"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Maybe.html#"><span class="hs-identifier">Data.Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Maybe.html#fromMaybe"><span class="hs-identifier">fromMaybe</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-61"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.html#"><span class="hs-identifier">Data.Map</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Map</span></span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-64"></span><span class="hs-comment">-- Unlinked BCOs</span><span>
</span><span id="line-65"></span><span>
</span><span id="line-66"></span><span class="hs-comment">-- CompiledByteCode represents the result of byte-code</span><span>
</span><span id="line-67"></span><span class="hs-comment">-- compiling a bunch of functions and data types</span><span>
</span><span id="line-68"></span><span>
</span><span id="line-69"></span><span class="hs-comment">-- | Finds external references.  Remember to remove the names</span><span>
</span><span id="line-70"></span><span class="hs-comment">-- defined by this group of BCOs themselves</span><span>
</span><span id="line-71"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#bcoFreeNames"><span class="hs-identifier hs-type">bcoFreeNames</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Unique.DSet.html#UniqDSet"><span class="hs-identifier hs-type">UniqDSet</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span>
</span><span id="line-72"></span><span id="bcoFreeNames"><span class="annot"><span class="annottext">bcoFreeNames :: UnlinkedBCO -&gt; UniqDSet Name
</span><a href="GHC.ByteCode.Asm.html#bcoFreeNames"><span class="hs-identifier hs-var hs-var">bcoFreeNames</span></a></span></span><span> </span><span id="local-6989586621681068716"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068716"><span class="hs-identifier hs-var">bco</span></a></span></span><span>
</span><span id="line-73"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; UniqDSet Name
</span><a href="#local-6989586621681068715"><span class="hs-identifier hs-var">bco_refs</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068716"><span class="hs-identifier hs-var">bco</span></a></span><span> </span><span class="annot"><span class="annottext">UniqDSet Name -&gt; UniqSet Name -&gt; UniqDSet Name
forall a. UniqDSet a -&gt; UniqSet a -&gt; UniqDSet a
</span><a href="GHC.Types.Unique.DSet.html#uniqDSetMinusUniqSet"><span class="hs-operator hs-var">`uniqDSetMinusUniqSet`</span></a></span><span> </span><span class="annot"><span class="annottext">[Name] -&gt; UniqSet Name
</span><a href="GHC.Types.Name.Set.html#mkNameSet"><span class="hs-identifier hs-var">mkNameSet</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; Name
</span><a href="GHC.ByteCode.Types.html#unlinkedBCOName"><span class="hs-identifier hs-var hs-var">unlinkedBCOName</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068716"><span class="hs-identifier hs-var">bco</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-74"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-75"></span><span>    </span><span id="local-6989586621681068715"><span class="annot"><span class="annottext">bco_refs :: UnlinkedBCO -&gt; UniqDSet Name
</span><a href="#local-6989586621681068715"><span class="hs-identifier hs-var hs-var">bco_refs</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">UArray Int Word16
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">UArray Int Word64
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621681068707"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068707"><span class="hs-identifier hs-var">nonptrs</span></a></span></span><span> </span><span id="local-6989586621681068706"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068706"><span class="hs-identifier hs-var">ptrs</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-76"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[UniqDSet Name] -&gt; UniqDSet Name
forall a. [UniqDSet a] -&gt; UniqDSet a
</span><a href="GHC.Types.Unique.DSet.html#unionManyUniqDSets"><span class="hs-identifier hs-var">unionManyUniqDSets</span></a></span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-77"></span><span>             </span><span class="annot"><span class="annottext">[Name] -&gt; UniqDSet Name
forall a. Uniquable a =&gt; [a] -&gt; UniqDSet a
</span><a href="GHC.Types.Unique.DSet.html#mkUniqDSet"><span class="hs-identifier hs-var">mkUniqDSet</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068703"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtrName"><span class="hs-identifier hs-type">BCOPtrName</span></a></span><span> </span><span id="local-6989586621681068703"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068703"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr -&gt; [BCOPtr]
forall a. SizedSeq a -&gt; [a]
</span><a href="../../ghci/src/SizedSeq.html#ssElts"><span class="hs-identifier hs-var">ssElts</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068706"><span class="hs-identifier hs-var">ptrs</span></a></span><span> </span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">UniqDSet Name -&gt; [UniqDSet Name] -&gt; [UniqDSet Name]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span>
</span><span id="line-78"></span><span>             </span><span class="annot"><span class="annottext">[Name] -&gt; UniqDSet Name
forall a. Uniquable a =&gt; [a] -&gt; UniqDSet a
</span><a href="GHC.Types.Unique.DSet.html#mkUniqDSet"><span class="hs-identifier hs-var">mkUniqDSet</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068701"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtrItbl"><span class="hs-identifier hs-type">BCONPtrItbl</span></a></span><span> </span><span id="local-6989586621681068701"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068701"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr -&gt; [BCONPtr]
forall a. SizedSeq a -&gt; [a]
</span><a href="../../ghci/src/SizedSeq.html#ssElts"><span class="hs-identifier hs-var">ssElts</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068707"><span class="hs-identifier hs-var">nonptrs</span></a></span><span> </span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">UniqDSet Name -&gt; [UniqDSet Name] -&gt; [UniqDSet Name]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span>
</span><span id="line-79"></span><span>             </span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; UniqDSet Name) -&gt; [UnlinkedBCO] -&gt; [UniqDSet Name]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; UniqDSet Name
</span><a href="#local-6989586621681068715"><span class="hs-identifier hs-var">bco_refs</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068699"><span class="hs-identifier hs-var">bco</span></a></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-type">BCOPtrBCO</span></a></span><span> </span><span id="local-6989586621681068699"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068699"><span class="hs-identifier hs-var">bco</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr -&gt; [BCOPtr]
forall a. SizedSeq a -&gt; [a]
</span><a href="../../ghci/src/SizedSeq.html#ssElts"><span class="hs-identifier hs-var">ssElts</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068706"><span class="hs-identifier hs-var">ptrs</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-80"></span><span>          </span><span class="hs-special">)</span><span>
</span><span id="line-81"></span><span>
</span><span id="line-82"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-83"></span><span class="hs-comment">-- The bytecode assembler</span><span>
</span><span id="line-84"></span><span>
</span><span id="line-85"></span><span class="hs-comment">-- The object format for bytecodes is: 16 bits for the opcode, and 16</span><span>
</span><span id="line-86"></span><span class="hs-comment">-- for each field -- so the code can be considered a sequence of</span><span>
</span><span id="line-87"></span><span class="hs-comment">-- 16-bit ints.  Each field denotes either a stack offset or number of</span><span>
</span><span id="line-88"></span><span class="hs-comment">-- items on the stack (eg SLIDE), and index into the pointer table (eg</span><span>
</span><span id="line-89"></span><span class="hs-comment">-- PUSH_G), an index into the literal table (eg PUSH_I/D/L), or a</span><span>
</span><span id="line-90"></span><span class="hs-comment">-- bytecode address in this BCO.</span><span>
</span><span id="line-91"></span><span>
</span><span id="line-92"></span><span class="hs-comment">-- Top level assembler fn.</span><span>
</span><span id="line-93"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleBCOs"><span class="hs-identifier hs-type">assembleBCOs</span></a></span><span>
</span><span id="line-94"></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Driver.Types.html#HscEnv"><span class="hs-identifier hs-type">HscEnv</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Instr.html#ProtoBCO"><span class="hs-identifier hs-type">ProtoBCO</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../ghci/src/GHCi.RemoteTypes.html#RemotePtr"><span class="hs-identifier hs-type">RemotePtr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-95"></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#ModBreaks"><span class="hs-identifier hs-type">ModBreaks</span></a></span><span>
</span><span id="line-96"></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#CompiledByteCode"><span class="hs-identifier hs-type">CompiledByteCode</span></a></span><span>
</span><span id="line-97"></span><span id="assembleBCOs"><span class="annot"><span class="annottext">assembleBCOs :: HscEnv
-&gt; [ProtoBCO Name]
-&gt; [TyCon]
-&gt; [RemotePtr ()]
-&gt; Maybe ModBreaks
-&gt; IO CompiledByteCode
</span><a href="GHC.ByteCode.Asm.html#assembleBCOs"><span class="hs-identifier hs-var hs-var">assembleBCOs</span></a></span></span><span> </span><span id="local-6989586621681068697"><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068697"><span class="hs-identifier hs-var">hsc_env</span></a></span></span><span> </span><span id="local-6989586621681068696"><span class="annot"><span class="annottext">[ProtoBCO Name]
</span><a href="#local-6989586621681068696"><span class="hs-identifier hs-var">proto_bcos</span></a></span></span><span> </span><span id="local-6989586621681068695"><span class="annot"><span class="annottext">[TyCon]
</span><a href="#local-6989586621681068695"><span class="hs-identifier hs-var">tycons</span></a></span></span><span> </span><span id="local-6989586621681068694"><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068694"><span class="hs-identifier hs-var">top_strs</span></a></span></span><span> </span><span id="local-6989586621681068693"><span class="annot"><span class="annottext">Maybe ModBreaks
</span><a href="#local-6989586621681068693"><span class="hs-identifier hs-var">modbreaks</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-98"></span><span>  </span><span id="local-6989586621681068692"><span class="annot"><span class="annottext">ItblEnv
</span><a href="#local-6989586621681068692"><span class="hs-identifier hs-var">itblenv</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HscEnv -&gt; [TyCon] -&gt; IO ItblEnv
</span><a href="GHC.ByteCode.InfoTable.html#mkITbls"><span class="hs-identifier hs-var">mkITbls</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068697"><span class="hs-identifier hs-var">hsc_env</span></a></span><span> </span><span class="annot"><span class="annottext">[TyCon]
</span><a href="#local-6989586621681068695"><span class="hs-identifier hs-var">tycons</span></a></span><span>
</span><span id="line-99"></span><span>  </span><span id="local-6989586621681068690"><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068690"><span class="hs-identifier hs-var">bcos</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(ProtoBCO Name -&gt; IO UnlinkedBCO)
-&gt; [ProtoBCO Name] -&gt; IO [UnlinkedBCO]
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Traversable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m (t b)
</span><a href="../../base/src/Data.Traversable.html#mapM"><span class="hs-identifier hs-var">mapM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var">assembleBCO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DynFlags -&gt; Platform
</span><a href="GHC.Driver.Session.html#targetPlatform"><span class="hs-identifier hs-var hs-var">targetPlatform</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">HscEnv -&gt; DynFlags
</span><a href="GHC.Driver.Types.html#hsc_dflags"><span class="hs-identifier hs-var hs-var">hsc_dflags</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068697"><span class="hs-identifier hs-var">hsc_env</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[ProtoBCO Name]
</span><a href="#local-6989586621681068696"><span class="hs-identifier hs-var">proto_bcos</span></a></span><span>
</span><span id="line-100"></span><span>  </span><span class="hs-special">(</span><span id="local-6989586621681068685"><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068685"><span class="hs-identifier hs-var">bcos'</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068684"><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068684"><span class="hs-identifier hs-var">ptrs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HscEnv -&gt; [UnlinkedBCO] -&gt; IO ([UnlinkedBCO], [RemotePtr ()])
</span><a href="GHC.ByteCode.Asm.html#mallocStrings"><span class="hs-identifier hs-var">mallocStrings</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068697"><span class="hs-identifier hs-var">hsc_env</span></a></span><span> </span><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068690"><span class="hs-identifier hs-var">bcos</span></a></span><span>
</span><span id="line-101"></span><span>  </span><span class="annot"><span class="annottext">CompiledByteCode -&gt; IO CompiledByteCode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">CompiledByteCode :: [UnlinkedBCO]
-&gt; ItblEnv
-&gt; [FFIInfo]
-&gt; [RemotePtr ()]
-&gt; Maybe ModBreaks
-&gt; CompiledByteCode
</span><a href="GHC.ByteCode.Types.html#CompiledByteCode"><span class="hs-identifier hs-type">CompiledByteCode</span></a></span><span>
</span><span id="line-102"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">bc_bcos :: [UnlinkedBCO]
</span><a href="GHC.ByteCode.Types.html#bc_bcos"><span class="hs-identifier hs-var">bc_bcos</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068685"><span class="hs-identifier hs-var">bcos'</span></a></span><span>
</span><span id="line-103"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">bc_itbls :: ItblEnv
</span><a href="GHC.ByteCode.Types.html#bc_itbls"><span class="hs-identifier hs-var">bc_itbls</span></a></span><span> </span><span class="hs-glyph">=</span><span>  </span><span class="annot"><span class="annottext">ItblEnv
</span><a href="#local-6989586621681068692"><span class="hs-identifier hs-var">itblenv</span></a></span><span>
</span><span id="line-104"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">bc_ffis :: [FFIInfo]
</span><a href="GHC.ByteCode.Types.html#bc_ffis"><span class="hs-identifier hs-var">bc_ffis</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ProtoBCO Name -&gt; [FFIInfo]) -&gt; [ProtoBCO Name] -&gt; [FFIInfo]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="annot"><span class="annottext">ProtoBCO Name -&gt; [FFIInfo]
forall a. ProtoBCO a -&gt; [FFIInfo]
</span><a href="GHC.ByteCode.Instr.html#protoBCOFFIs"><span class="hs-identifier hs-var hs-var">protoBCOFFIs</span></a></span><span> </span><span class="annot"><span class="annottext">[ProtoBCO Name]
</span><a href="#local-6989586621681068696"><span class="hs-identifier hs-var">proto_bcos</span></a></span><span>
</span><span id="line-105"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">bc_strs :: [RemotePtr ()]
</span><a href="GHC.ByteCode.Types.html#bc_strs"><span class="hs-identifier hs-var">bc_strs</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068694"><span class="hs-identifier hs-var">top_strs</span></a></span><span> </span><span class="annot"><span class="annottext">[RemotePtr ()] -&gt; [RemotePtr ()] -&gt; [RemotePtr ()]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068684"><span class="hs-identifier hs-var">ptrs</span></a></span><span>
</span><span id="line-106"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">bc_breaks :: Maybe ModBreaks
</span><a href="GHC.ByteCode.Types.html#bc_breaks"><span class="hs-identifier hs-var">bc_breaks</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe ModBreaks
</span><a href="#local-6989586621681068693"><span class="hs-identifier hs-var">modbreaks</span></a></span><span>
</span><span id="line-107"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-108"></span><span>
</span><span id="line-109"></span><span class="hs-comment">-- Find all the literal strings and malloc them together.  We want to</span><span>
</span><span id="line-110"></span><span class="hs-comment">-- do this because:</span><span>
</span><span id="line-111"></span><span class="hs-comment">--</span><span>
</span><span id="line-112"></span><span class="hs-comment">--  a) It should be done when we compile the module, not each time we relink it</span><span>
</span><span id="line-113"></span><span class="hs-comment">--  b) For -fexternal-interpreter It's more efficient to malloc the strings</span><span>
</span><span id="line-114"></span><span class="hs-comment">--     as a single batch message, especially when compiling in parallel.</span><span>
</span><span id="line-115"></span><span class="hs-comment">--</span><span>
</span><span id="line-116"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mallocStrings"><span class="hs-identifier hs-type">mallocStrings</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Driver.Types.html#HscEnv"><span class="hs-identifier hs-type">HscEnv</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../ghci/src/GHCi.RemoteTypes.html#RemotePtr"><span class="hs-identifier hs-type">RemotePtr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-117"></span><span id="mallocStrings"><span class="annot"><span class="annottext">mallocStrings :: HscEnv -&gt; [UnlinkedBCO] -&gt; IO ([UnlinkedBCO], [RemotePtr ()])
</span><a href="GHC.ByteCode.Asm.html#mallocStrings"><span class="hs-identifier hs-var hs-var">mallocStrings</span></a></span></span><span> </span><span id="local-6989586621681068674"><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068674"><span class="hs-identifier hs-var">hsc_env</span></a></span></span><span> </span><span id="local-6989586621681068673"><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068673"><span class="hs-identifier hs-var">ulbcos</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-118"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068668"><span class="annot"><span class="annottext">bytestrings :: [ByteString]
</span><a href="#local-6989586621681068668"><span class="hs-identifier hs-var hs-var">bytestrings</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; [ByteString]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#reverse"><span class="hs-identifier hs-var">reverse</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">State [ByteString] () -&gt; [ByteString] -&gt; [ByteString]
forall s a. State s a -&gt; s -&gt; s
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#execState"><span class="hs-identifier hs-var">execState</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; State [ByteString] ())
-&gt; [UnlinkedBCO] -&gt; State [ByteString] ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; State [ByteString] ()
forall {m :: * -&gt; *}.
Monad m =&gt;
UnlinkedBCO -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068664"><span class="hs-identifier hs-var">collect</span></a></span><span> </span><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068673"><span class="hs-identifier hs-var">ulbcos</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-119"></span><span>  </span><span id="local-6989586621681068663"><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068663"><span class="hs-identifier hs-var">ptrs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HscEnv -&gt; Message [RemotePtr ()] -&gt; IO [RemotePtr ()]
forall a. Binary a =&gt; HscEnv -&gt; Message a -&gt; IO a
</span><a href="GHC.Runtime.Interpreter.html#iservCmd"><span class="hs-identifier hs-var">iservCmd</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068674"><span class="hs-identifier hs-var">hsc_env</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[ByteString] -&gt; Message [RemotePtr ()]
</span><a href="../../ghci/src/GHCi.Message.html#MallocStrings"><span class="hs-identifier hs-var">MallocStrings</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621681068668"><span class="hs-identifier hs-var">bytestrings</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-120"></span><span>  </span><span class="annot"><span class="annottext">([UnlinkedBCO], [RemotePtr ()])
-&gt; IO ([UnlinkedBCO], [RemotePtr ()])
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">State [RemotePtr ()] [UnlinkedBCO]
-&gt; [RemotePtr ()] -&gt; [UnlinkedBCO]
forall s a. State s a -&gt; s -&gt; a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#evalState"><span class="hs-identifier hs-var">evalState</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; StateT [RemotePtr ()] Identity UnlinkedBCO)
-&gt; [UnlinkedBCO] -&gt; State [RemotePtr ()] [UnlinkedBCO]
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Traversable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m (t b)
</span><a href="../../base/src/Data.Traversable.html#mapM"><span class="hs-identifier hs-var">mapM</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; StateT [RemotePtr ()] Identity UnlinkedBCO
forall {m :: * -&gt; *} {a}.
Monad m =&gt;
UnlinkedBCO -&gt; StateT [RemotePtr a] m UnlinkedBCO
</span><a href="#local-6989586621681068659"><span class="hs-identifier hs-var">splice</span></a></span><span> </span><span class="annot"><span class="annottext">[UnlinkedBCO]
</span><a href="#local-6989586621681068673"><span class="hs-identifier hs-var">ulbcos</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068663"><span class="hs-identifier hs-var">ptrs</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068663"><span class="hs-identifier hs-var">ptrs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-121"></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-122"></span><span>  </span><span id="local-6989586621681068659"><span class="annot"><span class="annottext">splice :: UnlinkedBCO -&gt; StateT [RemotePtr a] m UnlinkedBCO
</span><a href="#local-6989586621681068659"><span class="hs-identifier hs-var hs-var">splice</span></a></span></span><span> </span><span id="local-6989586621681068639"><span class="annot"><span class="annottext">bco :: UnlinkedBCO
</span><a href="#local-6989586621681068639"><span class="hs-identifier hs-var">bco</span></a></span></span><span class="hs-glyph">@</span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span class="hs-special">{</span><span id="local-6989586621681068633"><span id="local-6989586621681068634"><span id="local-6989586621681068635"><span id="local-6989586621681068636"><span id="local-6989586621681068637"><span id="local-6989586621681068638"><span class="annot"><span class="annottext">Int
UArray Int Word16
UArray Int Word64
SizedSeq BCONPtr
SizedSeq BCOPtr
Name
unlinkedBCOPtrs :: UnlinkedBCO -&gt; SizedSeq BCOPtr
unlinkedBCOLits :: UnlinkedBCO -&gt; SizedSeq BCONPtr
unlinkedBCOInstrs :: UnlinkedBCO -&gt; UArray Int Word16
unlinkedBCOBitmap :: UnlinkedBCO -&gt; UArray Int Word64
unlinkedBCOArity :: UnlinkedBCO -&gt; Int
unlinkedBCOPtrs :: SizedSeq BCOPtr
unlinkedBCOLits :: SizedSeq BCONPtr
unlinkedBCOBitmap :: UArray Int Word64
unlinkedBCOInstrs :: UArray Int Word16
unlinkedBCOArity :: Int
unlinkedBCOName :: Name
unlinkedBCOName :: UnlinkedBCO -&gt; Name
</span><a href="GHC.ByteCode.Types.html#unlinkedBCOPtrs"><span class="hs-glyph hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var">..</span></a></span></span></span></span></span></span></span><span class="hs-special">}</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-123"></span><span>    </span><span id="local-6989586621681068627"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068627"><span class="hs-identifier hs-var">lits</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr)
-&gt; SizedSeq BCONPtr -&gt; StateT [RemotePtr a] m (SizedSeq BCONPtr)
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Traversable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m (t b)
</span><a href="../../base/src/Data.Traversable.html#mapM"><span class="hs-identifier hs-var">mapM</span></a></span><span> </span><span class="annot"><span class="annottext">BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr
forall {m :: * -&gt; *} {a}.
Monad m =&gt;
BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr
</span><a href="#local-6989586621681068626"><span class="hs-identifier hs-var">spliceLit</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068634"><span class="hs-identifier hs-var">unlinkedBCOLits</span></a></span><span>
</span><span id="line-124"></span><span>    </span><span id="local-6989586621681068625"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068625"><span class="hs-identifier hs-var">ptrs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(BCOPtr -&gt; StateT [RemotePtr a] m BCOPtr)
-&gt; SizedSeq BCOPtr -&gt; StateT [RemotePtr a] m (SizedSeq BCOPtr)
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Traversable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m (t b)
</span><a href="../../base/src/Data.Traversable.html#mapM"><span class="hs-identifier hs-var">mapM</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; StateT [RemotePtr a] m BCOPtr
</span><a href="#local-6989586621681068624"><span class="hs-identifier hs-var">splicePtr</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068633"><span class="hs-identifier hs-var">unlinkedBCOPtrs</span></a></span><span>
</span><span id="line-125"></span><span>    </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; StateT [RemotePtr a] m UnlinkedBCO
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068639"><span class="hs-identifier hs-var">bco</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">unlinkedBCOLits :: SizedSeq BCONPtr
</span><a href="GHC.ByteCode.Types.html#unlinkedBCOLits"><span class="hs-identifier hs-var">unlinkedBCOLits</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068627"><span class="hs-identifier hs-var">lits</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">unlinkedBCOPtrs :: SizedSeq BCOPtr
</span><a href="GHC.ByteCode.Types.html#unlinkedBCOPtrs"><span class="hs-identifier hs-var">unlinkedBCOPtrs</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068625"><span class="hs-identifier hs-var">ptrs</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-126"></span><span>
</span><span id="line-127"></span><span>  </span><span id="local-6989586621681068626"><span class="annot"><span class="annottext">spliceLit :: BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr
</span><a href="#local-6989586621681068626"><span class="hs-identifier hs-var hs-var">spliceLit</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtrStr"><span class="hs-identifier hs-type">BCONPtrStr</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-128"></span><span>    </span><span id="local-6989586621681068611"><span class="annot"><span class="annottext">[RemotePtr a]
</span><a href="#local-6989586621681068611"><span class="hs-identifier hs-var">rptrs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">StateT [RemotePtr a] m [RemotePtr a]
forall (m :: * -&gt; *) s. Monad m =&gt; StateT s m s
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-129"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">[RemotePtr a]
</span><a href="#local-6989586621681068611"><span class="hs-identifier hs-var">rptrs</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-130"></span><span>      </span><span class="hs-special">(</span><span class="annot"><a href="../../ghci/src/GHCi.RemoteTypes.html#RemotePtr"><span class="hs-identifier hs-type">RemotePtr</span></a></span><span> </span><span id="local-6989586621681068608"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621681068608"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span> </span><span id="local-6989586621681068607"><span class="annot"><span class="annottext">[RemotePtr a]
</span><a href="#local-6989586621681068607"><span class="hs-identifier hs-var">rest</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-131"></span><span>        </span><span class="annot"><span class="annottext">[RemotePtr a] -&gt; StateT [RemotePtr a] m ()
forall (m :: * -&gt; *) s. Monad m =&gt; s -&gt; StateT s m ()
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[RemotePtr a]
</span><a href="#local-6989586621681068607"><span class="hs-identifier hs-var">rest</span></a></span><span>
</span><span id="line-132"></span><span>        </span><span class="annot"><span class="annottext">BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; BCONPtr
</span><a href="GHC.ByteCode.Types.html#BCONPtrWord"><span class="hs-identifier hs-var">BCONPtrWord</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621681068608"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-133"></span><span>      </span><span class="annot"><span class="annottext">[RemotePtr a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; StateT [RemotePtr a] m BCONPtr
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;mallocStrings:spliceLit&quot;</span></span><span>
</span><span id="line-134"></span><span>  </span><span class="annot"><a href="#local-6989586621681068626"><span class="hs-identifier hs-var">spliceLit</span></a></span><span> </span><span id="local-6989586621681068603"><span class="annot"><span class="annottext">BCONPtr
</span><a href="#local-6989586621681068603"><span class="hs-identifier hs-var">other</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BCONPtr -&gt; StateT [RemotePtr a] m BCONPtr
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">BCONPtr
</span><a href="#local-6989586621681068603"><span class="hs-identifier hs-var">other</span></a></span><span>
</span><span id="line-135"></span><span>
</span><span id="line-136"></span><span>  </span><span id="local-6989586621681068624"><span class="annot"><span class="annottext">splicePtr :: BCOPtr -&gt; StateT [RemotePtr a] m BCOPtr
</span><a href="#local-6989586621681068624"><span class="hs-identifier hs-var hs-var">splicePtr</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-type">BCOPtrBCO</span></a></span><span> </span><span id="local-6989586621681068602"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068602"><span class="hs-identifier hs-var">bco</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-var">BCOPtrBCO</span></a></span><span> </span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; BCOPtr)
-&gt; StateT [RemotePtr a] m UnlinkedBCO
-&gt; StateT [RemotePtr a] m BCOPtr
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; StateT [RemotePtr a] m UnlinkedBCO
</span><a href="#local-6989586621681068659"><span class="hs-identifier hs-var">splice</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068602"><span class="hs-identifier hs-var">bco</span></a></span><span>
</span><span id="line-137"></span><span>  </span><span class="annot"><a href="#local-6989586621681068624"><span class="hs-identifier hs-var">splicePtr</span></a></span><span> </span><span id="local-6989586621681068600"><span class="annot"><span class="annottext">BCOPtr
</span><a href="#local-6989586621681068600"><span class="hs-identifier hs-var">other</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; StateT [RemotePtr a] m BCOPtr
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr
</span><a href="#local-6989586621681068600"><span class="hs-identifier hs-var">other</span></a></span><span>
</span><span id="line-138"></span><span>
</span><span id="line-139"></span><span>  </span><span id="local-6989586621681068664"><span class="annot"><span class="annottext">collect :: UnlinkedBCO -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068664"><span class="hs-identifier hs-var hs-var">collect</span></a></span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span class="hs-special">{</span><span id="local-6989586621681068584"><span id="local-6989586621681068585"><span id="local-6989586621681068586"><span id="local-6989586621681068587"><span id="local-6989586621681068588"><span id="local-6989586621681068589"><span class="annot"><span class="annottext">Int
UArray Int Word16
UArray Int Word64
SizedSeq BCONPtr
SizedSeq BCOPtr
Name
unlinkedBCOPtrs :: SizedSeq BCOPtr
unlinkedBCOLits :: SizedSeq BCONPtr
unlinkedBCOBitmap :: UArray Int Word64
unlinkedBCOInstrs :: UArray Int Word16
unlinkedBCOArity :: Int
unlinkedBCOName :: Name
unlinkedBCOPtrs :: UnlinkedBCO -&gt; SizedSeq BCOPtr
unlinkedBCOLits :: UnlinkedBCO -&gt; SizedSeq BCONPtr
unlinkedBCOInstrs :: UnlinkedBCO -&gt; UArray Int Word16
unlinkedBCOBitmap :: UnlinkedBCO -&gt; UArray Int Word64
unlinkedBCOArity :: UnlinkedBCO -&gt; Int
unlinkedBCOName :: UnlinkedBCO -&gt; Name
</span><a href="#local-6989586621681068584"><span class="hs-glyph hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var">..</span></a></span></span></span></span></span></span></span><span class="hs-special">}</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-140"></span><span>    </span><span class="annot"><span class="annottext">(BCONPtr -&gt; StateT [ByteString] m ())
-&gt; SizedSeq BCONPtr -&gt; StateT [ByteString] m ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">BCONPtr -&gt; StateT [ByteString] m ()
forall {m :: * -&gt; *}.
Monad m =&gt;
BCONPtr -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068583"><span class="hs-identifier hs-var">collectLit</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068585"><span class="hs-identifier hs-var">unlinkedBCOLits</span></a></span><span>
</span><span id="line-141"></span><span>    </span><span class="annot"><span class="annottext">(BCOPtr -&gt; StateT [ByteString] m ())
-&gt; SizedSeq BCOPtr -&gt; StateT [ByteString] m ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068582"><span class="hs-identifier hs-var">collectPtr</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068584"><span class="hs-identifier hs-var">unlinkedBCOPtrs</span></a></span><span>
</span><span id="line-142"></span><span>
</span><span id="line-143"></span><span>  </span><span id="local-6989586621681068583"><span class="annot"><span class="annottext">collectLit :: BCONPtr -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068583"><span class="hs-identifier hs-var hs-var">collectLit</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtrStr"><span class="hs-identifier hs-type">BCONPtrStr</span></a></span><span> </span><span id="local-6989586621681068575"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621681068575"><span class="hs-identifier hs-var">bs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-144"></span><span>    </span><span id="local-6989586621681068574"><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621681068574"><span class="hs-identifier hs-var">strs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">StateT [ByteString] m [ByteString]
forall (m :: * -&gt; *) s. Monad m =&gt; StateT s m s
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-145"></span><span>    </span><span class="annot"><span class="annottext">[ByteString] -&gt; StateT [ByteString] m ()
forall (m :: * -&gt; *) s. Monad m =&gt; s -&gt; StateT s m ()
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621681068575"><span class="hs-identifier hs-var">bs</span></a></span><span class="annot"><span class="annottext">ByteString -&gt; [ByteString] -&gt; [ByteString]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621681068574"><span class="hs-identifier hs-var">strs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-146"></span><span>  </span><span class="annot"><a href="#local-6989586621681068583"><span class="hs-identifier hs-var">collectLit</span></a></span><span> </span><span class="annot"><span class="annottext">BCONPtr
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; StateT [ByteString] m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span>  </span><span id="local-6989586621681068582"><span class="annot"><span class="annottext">collectPtr :: BCOPtr -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068582"><span class="hs-identifier hs-var hs-var">collectPtr</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-type">BCOPtrBCO</span></a></span><span> </span><span id="local-6989586621681068573"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068573"><span class="hs-identifier hs-var">bco</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; StateT [ByteString] m ()
</span><a href="#local-6989586621681068664"><span class="hs-identifier hs-var">collect</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068573"><span class="hs-identifier hs-var">bco</span></a></span><span>
</span><span id="line-149"></span><span>  </span><span class="annot"><a href="#local-6989586621681068582"><span class="hs-identifier hs-var">collectPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; StateT [ByteString] m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-150"></span><span>
</span><span id="line-151"></span><span>
</span><span id="line-152"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleOneBCO"><span class="hs-identifier hs-type">assembleOneBCO</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Driver.Types.html#HscEnv"><span class="hs-identifier hs-type">HscEnv</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Instr.html#ProtoBCO"><span class="hs-identifier hs-type">ProtoBCO</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span>
</span><span id="line-153"></span><span id="assembleOneBCO"><span class="annot"><span class="annottext">assembleOneBCO :: HscEnv -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleOneBCO"><span class="hs-identifier hs-var hs-var">assembleOneBCO</span></a></span></span><span> </span><span id="local-6989586621681068572"><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068572"><span class="hs-identifier hs-var">hsc_env</span></a></span></span><span> </span><span id="local-6989586621681068571"><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068571"><span class="hs-identifier hs-var">pbco</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-154"></span><span>  </span><span id="local-6989586621681068570"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068570"><span class="hs-identifier hs-var">ubco</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var">assembleBCO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DynFlags -&gt; Platform
</span><a href="GHC.Driver.Session.html#targetPlatform"><span class="hs-identifier hs-var hs-var">targetPlatform</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">HscEnv -&gt; DynFlags
</span><a href="GHC.Driver.Types.html#hsc_dflags"><span class="hs-identifier hs-var hs-var">hsc_dflags</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068572"><span class="hs-identifier hs-var">hsc_env</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068571"><span class="hs-identifier hs-var">pbco</span></a></span><span>
</span><span id="line-155"></span><span>  </span><span class="hs-special">(</span><span class="hs-special">[</span><span id="local-6989586621681068569"><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068569"><span class="hs-identifier hs-var">ubco'</span></a></span></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068568"><span class="annot"><span class="annottext">[RemotePtr ()]
</span><a href="#local-6989586621681068568"><span class="hs-identifier hs-var">_ptrs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HscEnv -&gt; [UnlinkedBCO] -&gt; IO ([UnlinkedBCO], [RemotePtr ()])
</span><a href="GHC.ByteCode.Asm.html#mallocStrings"><span class="hs-identifier hs-var">mallocStrings</span></a></span><span> </span><span class="annot"><span class="annottext">HscEnv
</span><a href="#local-6989586621681068572"><span class="hs-identifier hs-var">hsc_env</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068570"><span class="hs-identifier hs-var">ubco</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-156"></span><span>  </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; IO UnlinkedBCO
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068569"><span class="hs-identifier hs-var">ubco'</span></a></span><span>
</span><span id="line-157"></span><span>
</span><span id="line-158"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-type">assembleBCO</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Instr.html#ProtoBCO"><span class="hs-identifier hs-type">ProtoBCO</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-type">UnlinkedBCO</span></a></span><span>
</span><span id="line-159"></span><span id="assembleBCO"><span class="annot"><span class="annottext">assembleBCO :: Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var hs-var">assembleBCO</span></a></span></span><span> </span><span id="local-6989586621681068567"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068567"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Instr.html#ProtoBCO"><span class="hs-identifier hs-type">ProtoBCO</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">protoBCOName :: forall a. ProtoBCO a -&gt; a
</span><a href="GHC.ByteCode.Instr.html#protoBCOName"><span class="hs-identifier hs-var">protoBCOName</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621681068564"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068564"><span class="hs-identifier hs-var">nm</span></a></span></span><span>
</span><span id="line-160"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">protoBCOInstrs :: forall a. ProtoBCO a -&gt; [BCInstr]
</span><a href="GHC.ByteCode.Instr.html#protoBCOInstrs"><span class="hs-identifier hs-var">protoBCOInstrs</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621681068562"><span class="annot"><span class="annottext">[BCInstr]
</span><a href="#local-6989586621681068562"><span class="hs-identifier hs-var">instrs</span></a></span></span><span>
</span><span id="line-161"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">protoBCOBitmap :: forall a. ProtoBCO a -&gt; [StgWord]
</span><a href="GHC.ByteCode.Instr.html#protoBCOBitmap"><span class="hs-identifier hs-var">protoBCOBitmap</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621681068560"><span class="annot"><span class="annottext">[StgWord]
</span><a href="#local-6989586621681068560"><span class="hs-identifier hs-var">bitmap</span></a></span></span><span>
</span><span id="line-162"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">protoBCOBitmapSize :: forall a. ProtoBCO a -&gt; Word16
</span><a href="GHC.ByteCode.Instr.html#protoBCOBitmapSize"><span class="hs-identifier hs-var">protoBCOBitmapSize</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621681068558"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068558"><span class="hs-identifier hs-var">bsize</span></a></span></span><span>
</span><span id="line-163"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">protoBCOArity :: forall a. ProtoBCO a -&gt; Int
</span><a href="GHC.ByteCode.Instr.html#protoBCOArity"><span class="hs-identifier hs-var">protoBCOArity</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621681068556"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068556"><span class="hs-identifier hs-var">arity</span></a></span></span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-164"></span><span>  </span><span class="hs-comment">-- pass 1: collect up the offsets of the local labels.</span><span>
</span><span id="line-165"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068553"><span class="annot"><span class="annottext">asm :: Assembler ()
</span><a href="#local-6989586621681068553"><span class="hs-identifier hs-var hs-var">asm</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(BCInstr -&gt; Assembler ()) -&gt; [BCInstr] -&gt; Assembler ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Platform -&gt; BCInstr -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#assembleI"><span class="hs-identifier hs-var">assembleI</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068567"><span class="hs-identifier hs-var">platform</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[BCInstr]
</span><a href="#local-6989586621681068562"><span class="hs-identifier hs-var">instrs</span></a></span><span>
</span><span id="line-166"></span><span>
</span><span id="line-167"></span><span>      </span><span id="local-6989586621681068550"><span class="annot"><span class="annottext">initial_offset :: Word
</span><a href="#local-6989586621681068550"><span class="hs-identifier hs-var hs-var">initial_offset</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">0</span></span><span>
</span><span id="line-168"></span><span>
</span><span id="line-169"></span><span>      </span><span class="hs-comment">-- Jump instructions are variable-sized, there are long and short variants</span><span>
</span><span id="line-170"></span><span>      </span><span class="hs-comment">-- depending on the magnitude of the offset.  However, we can't tell what</span><span>
</span><span id="line-171"></span><span>      </span><span class="hs-comment">-- size instructions we will need until we have calculated the offsets of</span><span>
</span><span id="line-172"></span><span>      </span><span class="hs-comment">-- the labels, which depends on the size of the instructions...  So we</span><span>
</span><span id="line-173"></span><span>      </span><span class="hs-comment">-- first create the label environment assuming that all jumps are short,</span><span>
</span><span id="line-174"></span><span>      </span><span class="hs-comment">-- and if the final size is indeed small enough for short jumps, we are</span><span>
</span><span id="line-175"></span><span>      </span><span class="hs-comment">-- done.  Otherwise, we repeat the calculation, and we force all jumps in</span><span>
</span><span id="line-176"></span><span>      </span><span class="hs-comment">-- this BCO to be long.</span><span>
</span><span id="line-177"></span><span>      </span><span class="hs-special">(</span><span id="local-6989586621681068549"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068549"><span class="hs-identifier hs-var">n_insns0</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068548"><span class="annot"><span class="annottext">LabelEnvMap
</span><a href="#local-6989586621681068548"><span class="hs-identifier hs-var">lbl_map0</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; Bool -&gt; Word -&gt; Assembler () -&gt; (Word, LabelEnvMap)
forall a.
Platform -&gt; Bool -&gt; Word -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="GHC.ByteCode.Asm.html#inspectAsm"><span class="hs-identifier hs-var">inspectAsm</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068567"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068550"><span class="hs-identifier hs-var">initial_offset</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler ()
</span><a href="#local-6989586621681068553"><span class="hs-identifier hs-var">asm</span></a></span><span>
</span><span id="line-178"></span><span>      </span><span class="hs-special">(</span><span class="hs-special">(</span><span id="local-6989586621681068546"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068546"><span class="hs-identifier hs-var">n_insns</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068545"><span class="annot"><span class="annottext">LabelEnvMap
</span><a href="#local-6989586621681068545"><span class="hs-identifier hs-var">lbl_map</span></a></span></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068544"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068544"><span class="hs-identifier hs-var">long_jumps</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-179"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#isLarge"><span class="hs-identifier hs-var">isLarge</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068549"><span class="hs-identifier hs-var">n_insns0</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Platform -&gt; Bool -&gt; Word -&gt; Assembler () -&gt; (Word, LabelEnvMap)
forall a.
Platform -&gt; Bool -&gt; Word -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="GHC.ByteCode.Asm.html#inspectAsm"><span class="hs-identifier hs-var">inspectAsm</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068567"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068550"><span class="hs-identifier hs-var">initial_offset</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler ()
</span><a href="#local-6989586621681068553"><span class="hs-identifier hs-var">asm</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-180"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068549"><span class="hs-identifier hs-var">n_insns0</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">LabelEnvMap
</span><a href="#local-6989586621681068548"><span class="hs-identifier hs-var">lbl_map0</span></a></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-special">)</span><span>
</span><span id="line-181"></span><span>
</span><span id="line-182"></span><span>      </span><span class="annot"><a href="#local-6989586621681068542"><span class="hs-identifier hs-type">env</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-183"></span><span>      </span><span id="local-6989586621681068542"><span class="annot"><span class="annottext">env :: Word16 -&gt; Word
</span><a href="#local-6989586621681068542"><span class="hs-identifier hs-var hs-var">env</span></a></span></span><span> </span><span id="local-6989586621681068541"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068541"><span class="hs-identifier hs-var">lbl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Maybe Word -&gt; Word
forall a. a -&gt; Maybe a -&gt; a
</span><a href="../../base/src/Data.Maybe.html#fromMaybe"><span class="hs-identifier hs-var">fromMaybe</span></a></span><span>
</span><span id="line-184"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; SDoc -&gt; Word
forall a. HasCallStack =&gt; String -&gt; SDoc -&gt; a
</span><a href="GHC.Utils.Outputable.html#pprPanic"><span class="hs-identifier hs-var">pprPanic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;assembleBCO.findLabel&quot;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; SDoc
forall a. Outputable a =&gt; a -&gt; SDoc
</span><a href="GHC.Utils.Outputable.html#ppr"><span class="hs-identifier hs-var">ppr</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068541"><span class="hs-identifier hs-var">lbl</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-185"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; LabelEnvMap -&gt; Maybe Word
forall k a. Ord k =&gt; k -&gt; Map k a -&gt; Maybe a
</span><a href="../../containers/src/Data.Map.Internal.html#lookup"><span class="hs-identifier hs-var">Map.lookup</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068541"><span class="hs-identifier hs-var">lbl</span></a></span><span> </span><span class="annot"><span class="annottext">LabelEnvMap
</span><a href="#local-6989586621681068545"><span class="hs-identifier hs-var">lbl_map</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-186"></span><span>
</span><span id="line-187"></span><span>  </span><span class="hs-comment">-- pass 2: run assembler and generate instructions, literals and pointers</span><span>
</span><span id="line-188"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068537"><span class="annot"><span class="annottext">initial_state :: (SizedSeq a, SizedSeq a, SizedSeq a)
</span><a href="#local-6989586621681068537"><span class="hs-identifier hs-var hs-var">initial_state</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq a
forall a. SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#emptySS"><span class="hs-identifier hs-var">emptySS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">SizedSeq a
forall a. SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#emptySS"><span class="hs-identifier hs-var">emptySS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">SizedSeq a
forall a. SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#emptySS"><span class="hs-identifier hs-var">emptySS</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-189"></span><span>  </span><span class="hs-special">(</span><span id="local-6989586621681068535"><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068535"><span class="hs-identifier hs-var">final_insns</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068534"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068534"><span class="hs-identifier hs-var">final_lits</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621681068533"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068533"><span class="hs-identifier hs-var">final_ptrs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
 -&gt; (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
 -&gt; IO (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr))
-&gt; (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
-&gt; IO (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="annot"><span class="annottext">StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
-&gt; (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
-&gt; IO (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
forall (m :: * -&gt; *) s a. Monad m =&gt; StateT s m a -&gt; s -&gt; m s
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#execStateT"><span class="hs-identifier hs-var">execStateT</span></a></span><span> </span><span class="annot"><span class="annottext">(SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
forall {a} {a} {a}. (SizedSeq a, SizedSeq a, SizedSeq a)
</span><a href="#local-6989586621681068537"><span class="hs-identifier hs-var">initial_state</span></a></span><span> </span><span class="annot"><span class="annottext">(StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
 -&gt; IO (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
-&gt; IO (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
-&gt; Bool
-&gt; (Word16 -&gt; Word)
-&gt; Assembler ()
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
forall a.
Platform
-&gt; Bool
-&gt; (Word16 -&gt; Word)
-&gt; Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="GHC.ByteCode.Asm.html#runAsm"><span class="hs-identifier hs-var">runAsm</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068567"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068544"><span class="hs-identifier hs-var">long_jumps</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word
</span><a href="#local-6989586621681068542"><span class="hs-identifier hs-var">env</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler ()
</span><a href="#local-6989586621681068553"><span class="hs-identifier hs-var">asm</span></a></span><span>
</span><span id="line-190"></span><span>
</span><span id="line-191"></span><span>  </span><span class="hs-comment">-- precomputed size should be equal to final size</span><span>
</span><span id="line-192"></span><span>  </span><span class="hs-identifier">ASSERT</span><span class="hs-special">(</span><span class="hs-identifier">n_insns</span><span> </span><span class="hs-operator">==</span><span> </span><span class="hs-identifier">sizeSS</span><span> </span><span class="hs-identifier">final_insns</span><span class="hs-special">)</span><span> </span><span class="hs-identifier">return</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-193"></span><span>
</span><span id="line-194"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068525"><span class="annot"><span class="annottext">asm_insns :: [Word16]
</span><a href="#local-6989586621681068525"><span class="hs-identifier hs-var hs-var">asm_insns</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq Word16 -&gt; [Word16]
forall a. SizedSeq a -&gt; [a]
</span><a href="../../ghci/src/SizedSeq.html#ssElts"><span class="hs-identifier hs-var">ssElts</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068535"><span class="hs-identifier hs-var">final_insns</span></a></span><span>
</span><span id="line-195"></span><span>      </span><span id="local-6989586621681068516"><span class="annot"><span class="annottext">insns_arr :: UArray Int Word16
</span><a href="#local-6989586621681068516"><span class="hs-identifier hs-var hs-var">insns_arr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; [Word16] -&gt; UArray Int Word16
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
(i, i) -&gt; [e] -&gt; a i e
</span><a href="../../array/src/Data.Array.Base.html#listArray"><span class="hs-identifier hs-var">Array.listArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068546"><span class="hs-identifier hs-var">n_insns</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Word16]
</span><a href="#local-6989586621681068525"><span class="hs-identifier hs-var">asm_insns</span></a></span><span>
</span><span id="line-196"></span><span>      </span><span id="local-6989586621681068514"><span class="annot"><span class="annottext">bitmap_arr :: UArray Int Word64
</span><a href="#local-6989586621681068514"><span class="hs-identifier hs-var hs-var">bitmap_arr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [StgWord] -&gt; UArray Int Word64
</span><a href="GHC.ByteCode.Asm.html#mkBitmapArray"><span class="hs-identifier hs-var">mkBitmapArray</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068558"><span class="hs-identifier hs-var">bsize</span></a></span><span> </span><span class="annot"><span class="annottext">[StgWord]
</span><a href="#local-6989586621681068560"><span class="hs-identifier hs-var">bitmap</span></a></span><span>
</span><span id="line-197"></span><span>      </span><span id="local-6989586621681068512"><span class="annot"><span class="annottext">ul_bco :: UnlinkedBCO
</span><a href="#local-6989586621681068512"><span class="hs-identifier hs-var hs-var">ul_bco</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name
-&gt; Int
-&gt; UArray Int Word16
-&gt; UArray Int Word64
-&gt; SizedSeq BCONPtr
-&gt; SizedSeq BCOPtr
-&gt; UnlinkedBCO
</span><a href="GHC.ByteCode.Types.html#UnlinkedBCO"><span class="hs-identifier hs-var">UnlinkedBCO</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068564"><span class="hs-identifier hs-var">nm</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068556"><span class="hs-identifier hs-var">arity</span></a></span><span> </span><span class="annot"><span class="annottext">UArray Int Word16
</span><a href="#local-6989586621681068516"><span class="hs-identifier hs-var">insns_arr</span></a></span><span> </span><span class="annot"><span class="annottext">UArray Int Word64
</span><a href="#local-6989586621681068514"><span class="hs-identifier hs-var">bitmap_arr</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068534"><span class="hs-identifier hs-var">final_lits</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068533"><span class="hs-identifier hs-var">final_ptrs</span></a></span><span>
</span><span id="line-198"></span><span>
</span><span id="line-199"></span><span>  </span><span class="hs-comment">-- 8 Aug 01: Finalisers aren't safe when attached to non-primitive</span><span>
</span><span id="line-200"></span><span>  </span><span class="hs-comment">-- objects, since they might get run too early.  Disable this until</span><span>
</span><span id="line-201"></span><span>  </span><span class="hs-comment">-- we figure out what to do.</span><span>
</span><span id="line-202"></span><span>  </span><span class="hs-comment">-- when (notNull malloced) (addFinalizer ul_bco (mapM_ zonk malloced))</span><span>
</span><span id="line-203"></span><span>
</span><span id="line-204"></span><span>  </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; IO UnlinkedBCO
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO
</span><a href="#local-6989586621681068512"><span class="hs-identifier hs-var">ul_bco</span></a></span><span>
</span><span id="line-205"></span><span>
</span><span id="line-206"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mkBitmapArray"><span class="hs-identifier hs-type">mkBitmapArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Runtime.Heap.Layout.html#StgWord"><span class="hs-identifier hs-type">StgWord</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-207"></span><span class="hs-comment">-- Here the return type must be an array of Words, not StgWords,</span><span>
</span><span id="line-208"></span><span class="hs-comment">-- because the underlying ByteArray# will end up as a component</span><span>
</span><span id="line-209"></span><span class="hs-comment">-- of a BCO object.</span><span>
</span><span id="line-210"></span><span id="mkBitmapArray"><span class="annot"><span class="annottext">mkBitmapArray :: Word16 -&gt; [StgWord] -&gt; UArray Int Word64
</span><a href="GHC.ByteCode.Asm.html#mkBitmapArray"><span class="hs-identifier hs-var hs-var">mkBitmapArray</span></a></span></span><span> </span><span id="local-6989586621681068511"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068511"><span class="hs-identifier hs-var">bsize</span></a></span></span><span> </span><span id="local-6989586621681068510"><span class="annot"><span class="annottext">[StgWord]
</span><a href="#local-6989586621681068510"><span class="hs-identifier hs-var">bitmap</span></a></span></span><span>
</span><span id="line-211"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; [Word64] -&gt; UArray Int Word64
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
(i, i) -&gt; [e] -&gt; a i e
</span><a href="../../array/src/Data.Array.Base.html#listArray"><span class="hs-identifier hs-var">Array.listArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[StgWord] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[StgWord]
</span><a href="#local-6989586621681068510"><span class="hs-identifier hs-var">bitmap</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([Word64] -&gt; UArray Int Word64) -&gt; [Word64] -&gt; UArray Int Word64
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-212"></span><span>      </span><span class="annot"><span class="annottext">Word16 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068511"><span class="hs-identifier hs-var">bsize</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; [Word64] -&gt; [Word64]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span> </span><span class="annot"><span class="annottext">(StgWord -&gt; Word64) -&gt; [StgWord] -&gt; [Word64]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Word64
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Word64) -&gt; (StgWord -&gt; Integer) -&gt; StgWord -&gt; Word64
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">StgWord -&gt; Integer
</span><a href="GHC.Runtime.Heap.Layout.html#fromStgWord"><span class="hs-identifier hs-var">fromStgWord</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[StgWord]
</span><a href="#local-6989586621681068510"><span class="hs-identifier hs-var">bitmap</span></a></span><span>
</span><span id="line-213"></span><span>
</span><span id="line-214"></span><span class="hs-comment">-- instrs nonptrs ptrs</span><span>
</span><span id="line-215"></span><span class="hs-keyword">type</span><span> </span><span id="AsmState"><span class="annot"><a href="GHC.ByteCode.Asm.html#AsmState"><span class="hs-identifier hs-var">AsmState</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghci/src/SizedSeq.html#SizedSeq"><span class="hs-identifier hs-type">SizedSeq</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-216"></span><span>                 </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#SizedSeq"><span class="hs-identifier hs-type">SizedSeq</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtr"><span class="hs-identifier hs-type">BCONPtr</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-217"></span><span>                 </span><span class="annot"><a href="../../ghci/src/SizedSeq.html#SizedSeq"><span class="hs-identifier hs-type">SizedSeq</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtr"><span class="hs-identifier hs-type">BCOPtr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-218"></span><span>
</span><span id="line-219"></span><span class="hs-keyword">data</span><span> </span><span id="Operand"><span class="annot"><a href="GHC.ByteCode.Asm.html#Operand"><span class="hs-identifier hs-var">Operand</span></a></span></span><span>
</span><span id="line-220"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span id="Op"><span class="annot"><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-var">Op</span></a></span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-221"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="SmallOp"><span class="annot"><a href="GHC.ByteCode.Asm.html#SmallOp"><span class="hs-identifier hs-var">SmallOp</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-222"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="LabelOp"><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelOp"><span class="hs-identifier hs-var">LabelOp</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-223"></span><span class="hs-comment">-- (unused)  | LargeOp Word</span><span>
</span><span id="line-224"></span><span>
</span><span id="line-225"></span><span class="hs-keyword">data</span><span> </span><span id="Assembler"><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-var">Assembler</span></a></span></span><span> </span><span id="local-6989586621681069011"><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-226"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span id="AllocPtr"><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-var">AllocPtr</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtr"><span class="hs-identifier hs-type">BCOPtr</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-227"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="AllocLit"><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-var">AllocLit</span></a></span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtr"><span class="hs-identifier hs-type">BCONPtr</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-228"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="AllocLabel"><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-var">AllocLabel</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-229"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="Emit"><span class="annot"><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-var">Emit</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Operand"><span class="hs-identifier hs-type">Operand</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-230"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="NullAsm"><span class="annot"><a href="GHC.ByteCode.Asm.html#NullAsm"><span class="hs-identifier hs-var">NullAsm</span></a></span></span><span> </span><span class="annot"><a href="#local-6989586621681069011"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-231"></span><span>  </span><span class="hs-keyword">deriving</span><span> </span><span class="hs-special">(</span><span id="local-6989586621681068489"><span id="local-6989586621681068496"><span class="annot"><span class="annottext">(forall a b. (a -&gt; b) -&gt; Assembler a -&gt; Assembler b)
-&gt; (forall a b. a -&gt; Assembler b -&gt; Assembler a)
-&gt; Functor Assembler
forall a b. a -&gt; Assembler b -&gt; Assembler a
forall a b. (a -&gt; b) -&gt; Assembler a -&gt; Assembler b
forall (f :: * -&gt; *).
(forall a b. (a -&gt; b) -&gt; f a -&gt; f b)
-&gt; (forall a b. a -&gt; f b -&gt; f a) -&gt; Functor f
&lt;$ :: forall a b. a -&gt; Assembler b -&gt; Assembler a
$c&lt;$ :: forall a b. a -&gt; Assembler b -&gt; Assembler a
fmap :: forall a b. (a -&gt; b) -&gt; Assembler a -&gt; Assembler b
$cfmap :: forall a b. (a -&gt; b) -&gt; Assembler a -&gt; Assembler b
</span><a href="../../base/src/GHC.Base.html#Functor"><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var">Functor</span></a></span></span></span><span class="hs-special">)</span><span>
</span><span id="line-232"></span><span>
</span><span id="line-233"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621681068474"><span id="local-6989586621681068476"><span id="local-6989586621681068478"><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-234"></span><span>    </span><span id="local-6989586621681068472"><span class="annot"><span class="annottext">pure :: forall a. a -&gt; Assembler a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var hs-var hs-var hs-var">pure</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler a
forall a. a -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#NullAsm"><span class="hs-identifier hs-var">NullAsm</span></a></span><span>
</span><span id="line-235"></span><span>    </span><span id="local-6989586621681068470"><span class="annot"><span class="annottext">&lt;*&gt; :: forall a b. Assembler (a -&gt; b) -&gt; Assembler a -&gt; Assembler b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">(&lt;*&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Assembler (a -&gt; b) -&gt; Assembler a -&gt; Assembler b
forall (m :: * -&gt; *) a b. Monad m =&gt; m (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#ap"><span class="hs-identifier hs-var">ap</span></a></span><span>
</span><span id="line-236"></span><span>
</span><span id="line-237"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621681068462"><span id="local-6989586621681068464"><span class="annot"><a href="../../base/src/GHC.Base.html#Monad"><span class="hs-identifier hs-type">Monad</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-238"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Asm.html#NullAsm"><span class="hs-identifier hs-type">NullAsm</span></a></span><span> </span><span id="local-6989586621681068456"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621681068456"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621681068455"><span class="annot"><span class="annottext">&gt;&gt;= :: forall a b. Assembler a -&gt; (a -&gt; Assembler b) -&gt; Assembler b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var hs-var hs-var hs-var">&gt;&gt;=</span></a></span></span><span> </span><span id="local-6989586621681068454"><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068454"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068454"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621681068456"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-239"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-type">AllocPtr</span></a></span><span> </span><span id="local-6989586621681068453"><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068453"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621681068452"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068452"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span id="local-6989586621681068451"><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068451"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; (Word -&gt; Assembler b) -&gt; Assembler b
forall a. IO BCOPtr -&gt; (Word -&gt; Assembler a) -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-var">AllocPtr</span></a></span><span> </span><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068453"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068452"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">(Word -&gt; Assembler a) -&gt; (a -&gt; Assembler b) -&gt; Word -&gt; Assembler b
forall (m :: * -&gt; *) a b c.
Monad m =&gt;
(a -&gt; m b) -&gt; (b -&gt; m c) -&gt; a -&gt; m c
</span><a href="../../base/src/Control.Monad.html#%3E%3D%3E"><span class="hs-operator hs-var">&gt;=&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068451"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-240"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-type">AllocLit</span></a></span><span> </span><span id="local-6989586621681068449"><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068449"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span id="local-6989586621681068448"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068448"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span id="local-6989586621681068447"><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068447"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; (Word -&gt; Assembler b) -&gt; Assembler b
forall a. [BCONPtr] -&gt; (Word -&gt; Assembler a) -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-var">AllocLit</span></a></span><span> </span><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068449"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068448"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">(Word -&gt; Assembler a) -&gt; (a -&gt; Assembler b) -&gt; Word -&gt; Assembler b
forall (m :: * -&gt; *) a b c.
Monad m =&gt;
(a -&gt; m b) -&gt; (b -&gt; m c) -&gt; a -&gt; m c
</span><a href="../../base/src/Control.Monad.html#%3E%3D%3E"><span class="hs-operator hs-var">&gt;=&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068447"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-241"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-type">AllocLabel</span></a></span><span> </span><span id="local-6989586621681068446"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068446"><span class="hs-identifier hs-var">lbl</span></a></span></span><span> </span><span id="local-6989586621681068445"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068445"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span id="local-6989586621681068444"><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068444"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Assembler b -&gt; Assembler b
forall a. Word16 -&gt; Assembler a -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-var">AllocLabel</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068446"><span class="hs-identifier hs-var">lbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068445"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a -&gt; (a -&gt; Assembler b) -&gt; Assembler b
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068444"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-242"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-type">Emit</span></a></span><span> </span><span id="local-6989586621681068443"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068443"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span id="local-6989586621681068442"><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068442"><span class="hs-identifier hs-var">ops</span></a></span></span><span> </span><span id="local-6989586621681068441"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068441"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span id="local-6989586621681068440"><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068440"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler b -&gt; Assembler b
forall a. Word16 -&gt; [Operand] -&gt; Assembler a -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-var">Emit</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068443"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068442"><span class="hs-identifier hs-var">ops</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068441"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a -&gt; (a -&gt; Assembler b) -&gt; Assembler b
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Assembler b
</span><a href="#local-6989586621681068440"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-243"></span><span>
</span><span id="line-244"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-type">ioptr</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtr"><span class="hs-identifier hs-type">BCOPtr</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-245"></span><span id="ioptr"><span class="annot"><span class="annottext">ioptr :: IO BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-var hs-var">ioptr</span></a></span></span><span> </span><span id="local-6989586621681068438"><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068438"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; (Word -&gt; Assembler Word) -&gt; Assembler Word
forall a. IO BCOPtr -&gt; (Word -&gt; Assembler a) -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-var">AllocPtr</span></a></span><span> </span><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068438"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler Word
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span>
</span><span id="line-246"></span><span>
</span><span id="line-247"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#ptr"><span class="hs-identifier hs-type">ptr</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.ByteCode.Types.html#BCOPtr"><span class="hs-identifier hs-type">BCOPtr</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-248"></span><span id="ptr"><span class="annot"><span class="annottext">ptr :: BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ptr"><span class="hs-identifier hs-var hs-var">ptr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-var">ioptr</span></a></span><span> </span><span class="annot"><span class="annottext">(IO BCOPtr -&gt; Assembler Word)
-&gt; (BCOPtr -&gt; IO BCOPtr) -&gt; BCOPtr -&gt; Assembler Word
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; IO BCOPtr
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span>
</span><span id="line-249"></span><span>
</span><span id="line-250"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-type">lit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Types.html#BCONPtr"><span class="hs-identifier hs-type">BCONPtr</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-251"></span><span id="lit"><span class="annot"><span class="annottext">lit :: [BCONPtr] -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-var hs-var">lit</span></a></span></span><span> </span><span id="local-6989586621681068435"><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068435"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; (Word -&gt; Assembler Word) -&gt; Assembler Word
forall a. [BCONPtr] -&gt; (Word -&gt; Assembler a) -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-var">AllocLit</span></a></span><span> </span><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068435"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler Word
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span>
</span><span id="line-252"></span><span>
</span><span id="line-253"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#label"><span class="hs-keyword hs-type">label</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-254"></span><span id="label"><span class="annot"><span class="annottext">label :: Word16 -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#label"><span class="hs-keyword hs-var hs-var">label</span></a></span></span><span> </span><span id="local-6989586621681068433"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068433"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Assembler () -&gt; Assembler ()
forall a. Word16 -&gt; Assembler a -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-var">AllocLabel</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068433"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">() -&gt; Assembler ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-255"></span><span>
</span><span id="line-256"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-type">emit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Operand"><span class="hs-identifier hs-type">Operand</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-257"></span><span id="emit"><span class="annot"><span class="annottext">emit :: Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var hs-var">emit</span></a></span></span><span> </span><span id="local-6989586621681068431"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068431"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span id="local-6989586621681068430"><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068430"><span class="hs-identifier hs-var">ops</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler () -&gt; Assembler ()
forall a. Word16 -&gt; [Operand] -&gt; Assembler a -&gt; Assembler a
</span><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-var">Emit</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068431"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068430"><span class="hs-identifier hs-var">ops</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">() -&gt; Assembler ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-258"></span><span>
</span><span id="line-259"></span><span class="hs-keyword">type</span><span> </span><span id="LabelEnv"><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelEnv"><span class="hs-identifier hs-var">LabelEnv</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-260"></span><span>
</span><span id="line-261"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#largeOp"><span class="hs-identifier hs-type">largeOp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Operand"><span class="hs-identifier hs-type">Operand</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span>
</span><span id="line-262"></span><span id="largeOp"><span class="annot"><span class="annottext">largeOp :: Bool -&gt; Operand -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#largeOp"><span class="hs-identifier hs-var hs-var">largeOp</span></a></span></span><span> </span><span id="local-6989586621681068427"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068427"><span class="hs-identifier hs-var">long_jumps</span></a></span></span><span> </span><span id="local-6989586621681068426"><span class="annot"><span class="annottext">Operand
</span><a href="#local-6989586621681068426"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Operand
</span><a href="#local-6989586621681068426"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-263"></span><span>   </span><span class="annot"><a href="GHC.ByteCode.Asm.html#SmallOp"><span class="hs-identifier hs-type">SmallOp</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-264"></span><span>   </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-type">Op</span></a></span><span> </span><span id="local-6989586621681068425"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068425"><span class="hs-identifier hs-var">w</span></a></span></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#isLarge"><span class="hs-identifier hs-var">isLarge</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068425"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-265"></span><span>   </span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelOp"><span class="hs-identifier hs-type">LabelOp</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068427"><span class="hs-identifier hs-var">long_jumps</span></a></span><span>
</span><span id="line-266"></span><span class="hs-comment">-- LargeOp _ -&gt; True</span><span>
</span><span id="line-267"></span><span>
</span><span id="line-268"></span><span id="local-6989586621681069051"><span class="annot"><a href="GHC.ByteCode.Asm.html#runAsm"><span class="hs-identifier hs-type">runAsm</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelEnv"><span class="hs-identifier hs-type">LabelEnv</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069051"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">StateT</span></a></span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#AsmState"><span class="hs-identifier hs-type">AsmState</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621681069051"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-269"></span><span id="runAsm"><span class="annot"><span class="annottext">runAsm :: forall a.
Platform
-&gt; Bool
-&gt; (Word16 -&gt; Word)
-&gt; Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="GHC.ByteCode.Asm.html#runAsm"><span class="hs-identifier hs-var hs-var">runAsm</span></a></span></span><span> </span><span id="local-6989586621681068424"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068424"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068423"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068423"><span class="hs-identifier hs-var">long_jumps</span></a></span></span><span> </span><span id="local-6989586621681068422"><span class="annot"><span class="annottext">Word16 -&gt; Word
</span><a href="#local-6989586621681068422"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
forall {a}.
Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span>
</span><span id="line-270"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-271"></span><span>    </span><span id="local-6989586621681068421"><span class="annot"><span class="annottext">go :: Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#NullAsm"><span class="hs-identifier hs-type">NullAsm</span></a></span><span> </span><span id="local-6989586621681068408"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621681068408"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621681068408"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-272"></span><span>    </span><span class="annot"><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-type">AllocPtr</span></a></span><span> </span><span id="local-6989586621681068407"><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068407"><span class="hs-identifier hs-var">p_io</span></a></span></span><span> </span><span id="local-6989586621681068406"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068406"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-273"></span><span>      </span><span id="local-6989586621681068405"><span class="annot"><span class="annottext">BCOPtr
</span><a href="#local-6989586621681068405"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO BCOPtr
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">IO BCOPtr
</span><a href="#local-6989586621681068407"><span class="hs-identifier hs-var">p_io</span></a></span><span>
</span><span id="line-274"></span><span>      </span><span id="local-6989586621681068403"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068403"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
 -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word
forall (m :: * -&gt; *) s a. Monad m =&gt; (s -&gt; (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#state"><span class="hs-identifier hs-var">state</span></a></span><span> </span><span class="annot"><span class="annottext">(((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
  -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
 -&gt; StateT
      (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word)
-&gt; ((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
    -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621681068401"><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068401"><span class="hs-identifier hs-var">st_i0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068400"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068400"><span class="hs-identifier hs-var">st_l0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068399"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068399"><span class="hs-identifier hs-var">st_p0</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-275"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068398"><span class="annot"><span class="annottext">st_p1 :: SizedSeq BCOPtr
</span><a href="#local-6989586621681068398"><span class="hs-identifier hs-var hs-var">st_p1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr -&gt; BCOPtr -&gt; SizedSeq BCOPtr
forall a. SizedSeq a -&gt; a -&gt; SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#addToSS"><span class="hs-identifier hs-var">addToSS</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068399"><span class="hs-identifier hs-var">st_p0</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr
</span><a href="#local-6989586621681068405"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-276"></span><span>        </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq BCOPtr -&gt; Word
forall a. SizedSeq a -&gt; Word
</span><a href="../../ghci/src/SizedSeq.html#sizeSS"><span class="hs-identifier hs-var">sizeSS</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068399"><span class="hs-identifier hs-var">st_p0</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068401"><span class="hs-identifier hs-var">st_i0</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068400"><span class="hs-identifier hs-var">st_l0</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068398"><span class="hs-identifier hs-var">st_p1</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-277"></span><span>      </span><span class="annot"><span class="annottext">Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">(Assembler a
 -&gt; StateT
      (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a)
-&gt; Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068406"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068403"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-278"></span><span>    </span><span class="annot"><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-type">AllocLit</span></a></span><span> </span><span id="local-6989586621681068396"><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068396"><span class="hs-identifier hs-var">lits</span></a></span></span><span> </span><span id="local-6989586621681068395"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068395"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-279"></span><span>      </span><span id="local-6989586621681068394"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068394"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
 -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word
forall (m :: * -&gt; *) s a. Monad m =&gt; (s -&gt; (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#state"><span class="hs-identifier hs-var">state</span></a></span><span> </span><span class="annot"><span class="annottext">(((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
  -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
 -&gt; StateT
      (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word)
-&gt; ((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
    -&gt; (Word, (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO Word
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621681068393"><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068393"><span class="hs-identifier hs-var">st_i0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068392"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068392"><span class="hs-identifier hs-var">st_l0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068391"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068391"><span class="hs-identifier hs-var">st_p0</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-280"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068390"><span class="annot"><span class="annottext">st_l1 :: SizedSeq BCONPtr
</span><a href="#local-6989586621681068390"><span class="hs-identifier hs-var hs-var">st_l1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr -&gt; [BCONPtr] -&gt; SizedSeq BCONPtr
forall a. SizedSeq a -&gt; [a] -&gt; SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#addListToSS"><span class="hs-identifier hs-var">addListToSS</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068392"><span class="hs-identifier hs-var">st_l0</span></a></span><span> </span><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068396"><span class="hs-identifier hs-var">lits</span></a></span><span>
</span><span id="line-281"></span><span>        </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq BCONPtr -&gt; Word
forall a. SizedSeq a -&gt; Word
</span><a href="../../ghci/src/SizedSeq.html#sizeSS"><span class="hs-identifier hs-var">sizeSS</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068392"><span class="hs-identifier hs-var">st_l0</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068393"><span class="hs-identifier hs-var">st_i0</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068390"><span class="hs-identifier hs-var">st_l1</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068391"><span class="hs-identifier hs-var">st_p0</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-282"></span><span>      </span><span class="annot"><span class="annottext">Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">(Assembler a
 -&gt; StateT
      (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a)
-&gt; Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068395"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-283"></span><span>    </span><span class="annot"><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-type">AllocLabel</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621681068388"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068388"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068388"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-284"></span><span>    </span><span class="annot"><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-type">Emit</span></a></span><span> </span><span id="local-6989586621681068387"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068387"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span id="local-6989586621681068386"><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068386"><span class="hs-identifier hs-var">ops</span></a></span></span><span> </span><span id="local-6989586621681068385"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068385"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-285"></span><span>      </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068383"><span class="annot"><span class="annottext">largeOps :: Bool
</span><a href="#local-6989586621681068383"><span class="hs-identifier hs-var hs-var">largeOps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Operand -&gt; Bool) -&gt; [Operand] -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; (a -&gt; Bool) -&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#any"><span class="hs-identifier hs-var">any</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; Operand -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#largeOp"><span class="hs-identifier hs-var">largeOp</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068423"><span class="hs-identifier hs-var">long_jumps</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068386"><span class="hs-identifier hs-var">ops</span></a></span><span>
</span><span id="line-286"></span><span>          </span><span id="local-6989586621681068381"><span class="annot"><span class="annottext">opcode :: Word16
</span><a href="#local-6989586621681068381"><span class="hs-identifier hs-var hs-var">opcode</span></a></span></span><span>
</span><span id="line-287"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068383"><span class="hs-identifier hs-var">largeOps</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#largeArgInstr"><span class="hs-identifier hs-var">largeArgInstr</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068387"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-288"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068387"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-289"></span><span>          </span><span id="local-6989586621681068378"><span class="annot"><span class="annottext">words :: [Word16]
</span><a href="#local-6989586621681068378"><span class="hs-identifier hs-var hs-var">words</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Operand -&gt; [Word16]) -&gt; [Operand] -&gt; [Word16]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="annot"><span class="annottext">Operand -&gt; [Word16]
</span><a href="#local-6989586621681068377"><span class="hs-identifier hs-var">expand</span></a></span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068386"><span class="hs-identifier hs-var">ops</span></a></span><span>
</span><span id="line-290"></span><span>          </span><span id="local-6989586621681068377"><span class="annot"><span class="annottext">expand :: Operand -&gt; [Word16]
</span><a href="#local-6989586621681068377"><span class="hs-identifier hs-var hs-var">expand</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#SmallOp"><span class="hs-identifier hs-type">SmallOp</span></a></span><span> </span><span id="local-6989586621681068374"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068374"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068374"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-291"></span><span>          </span><span class="annot"><a href="#local-6989586621681068377"><span class="hs-identifier hs-var">expand</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelOp"><span class="hs-identifier hs-type">LabelOp</span></a></span><span> </span><span id="local-6989586621681068373"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068373"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Operand -&gt; [Word16]
</span><a href="#local-6989586621681068377"><span class="hs-identifier hs-var">expand</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Operand
</span><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-var">Op</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; Word
</span><a href="#local-6989586621681068422"><span class="hs-identifier hs-var">e</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068373"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-292"></span><span>          </span><span class="annot"><a href="#local-6989586621681068377"><span class="hs-identifier hs-var">expand</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-type">Op</span></a></span><span> </span><span id="local-6989586621681068372"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068372"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068383"><span class="hs-identifier hs-var">largeOps</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; Word -&gt; [Word16]
</span><a href="GHC.ByteCode.Asm.html#largeArg"><span class="hs-identifier hs-var">largeArg</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068424"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068372"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068372"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-293"></span><span class="hs-comment">--        expand (LargeOp w) = largeArg platform w</span><span>
</span><span id="line-294"></span><span>      </span><span class="annot"><span class="annottext">((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
 -&gt; ((), (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
forall (m :: * -&gt; *) s a. Monad m =&gt; (s -&gt; (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#state"><span class="hs-identifier hs-var">state</span></a></span><span> </span><span class="annot"><span class="annottext">(((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
  -&gt; ((), (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
 -&gt; StateT
      (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ())
-&gt; ((SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)
    -&gt; ((), (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr)))
-&gt; StateT
     (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621681068370"><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068370"><span class="hs-identifier hs-var">st_i0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068369"><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068369"><span class="hs-identifier hs-var">st_l0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621681068368"><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068368"><span class="hs-identifier hs-var">st_p0</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-295"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068367"><span class="annot"><span class="annottext">st_i1 :: SizedSeq Word16
</span><a href="#local-6989586621681068367"><span class="hs-identifier hs-var hs-var">st_i1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SizedSeq Word16 -&gt; [Word16] -&gt; SizedSeq Word16
forall a. SizedSeq a -&gt; [a] -&gt; SizedSeq a
</span><a href="../../ghci/src/SizedSeq.html#addListToSS"><span class="hs-identifier hs-var">addListToSS</span></a></span><span> </span><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068370"><span class="hs-identifier hs-var">st_i0</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068381"><span class="hs-identifier hs-var">opcode</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Word16] -&gt; [Word16]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span> </span><span class="annot"><span class="annottext">[Word16]
</span><a href="#local-6989586621681068378"><span class="hs-identifier hs-var">words</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-296"></span><span>        </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SizedSeq Word16
</span><a href="#local-6989586621681068367"><span class="hs-identifier hs-var">st_i1</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCONPtr
</span><a href="#local-6989586621681068369"><span class="hs-identifier hs-var">st_l0</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">SizedSeq BCOPtr
</span><a href="#local-6989586621681068368"><span class="hs-identifier hs-var">st_p0</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-297"></span><span>      </span><span class="annot"><span class="annottext">Assembler a
-&gt; StateT (SizedSeq Word16, SizedSeq BCONPtr, SizedSeq BCOPtr) IO a
</span><a href="#local-6989586621681068421"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068385"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-298"></span><span>
</span><span id="line-299"></span><span class="hs-keyword">type</span><span> </span><span id="LabelEnvMap"><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelEnvMap"><span class="hs-identifier hs-var">LabelEnvMap</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.Internal.html#Map"><span class="hs-identifier hs-type">Map</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-300"></span><span>
</span><span id="line-301"></span><span class="hs-keyword">data</span><span> </span><span id="InspectState"><span class="annot"><a href="GHC.ByteCode.Asm.html#InspectState"><span class="hs-identifier hs-var">InspectState</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="InspectState"><span class="annot"><a href="GHC.ByteCode.Asm.html#InspectState"><span class="hs-identifier hs-var">InspectState</span></a></span></span><span>
</span><span id="line-302"></span><span>  </span><span class="hs-special">{</span><span> </span><span id="instrCount"><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#instrCount"><span class="hs-identifier hs-var hs-var">instrCount</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-303"></span><span>  </span><span class="hs-special">,</span><span> </span><span id="ptrCount"><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#ptrCount"><span class="hs-identifier hs-var hs-var">ptrCount</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-304"></span><span>  </span><span class="hs-special">,</span><span> </span><span id="litCount"><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#litCount"><span class="hs-identifier hs-var hs-var">litCount</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-305"></span><span>  </span><span class="hs-special">,</span><span> </span><span id="lblEnv"><span class="annot"><span class="annottext">InspectState -&gt; LabelEnvMap
</span><a href="GHC.ByteCode.Asm.html#lblEnv"><span class="hs-identifier hs-var hs-var">lblEnv</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelEnvMap"><span class="hs-identifier hs-type">LabelEnvMap</span></a></span><span>
</span><span id="line-306"></span><span>  </span><span class="hs-special">}</span><span>
</span><span id="line-307"></span><span>
</span><span id="line-308"></span><span id="local-6989586621681069072"><span class="annot"><a href="GHC.ByteCode.Asm.html#inspectAsm"><span class="hs-identifier hs-type">inspectAsm</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="annot"><a href="#local-6989586621681069072"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelEnvMap"><span class="hs-identifier hs-type">LabelEnvMap</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-309"></span><span id="inspectAsm"><span class="annot"><span class="annottext">inspectAsm :: forall a.
Platform -&gt; Bool -&gt; Word -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="GHC.ByteCode.Asm.html#inspectAsm"><span class="hs-identifier hs-var hs-var">inspectAsm</span></a></span></span><span> </span><span id="local-6989586621681068361"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068361"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068360"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068360"><span class="hs-identifier hs-var">long_jumps</span></a></span></span><span> </span><span id="local-6989586621681068359"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068359"><span class="hs-identifier hs-var">initial_offset</span></a></span></span><span>
</span><span id="line-310"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
forall {a}. InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Word -&gt; LabelEnvMap -&gt; InspectState
</span><a href="GHC.ByteCode.Asm.html#InspectState"><span class="hs-identifier hs-var">InspectState</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068359"><span class="hs-identifier hs-var">initial_offset</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">LabelEnvMap
forall k a. Map k a
</span><a href="../../containers/src/Data.Map.Internal.html#empty"><span class="hs-identifier hs-var">Map.empty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-311"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-312"></span><span>    </span><span id="local-6989586621681068358"><span class="annot"><span class="annottext">go :: InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621681068352"><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068352"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#NullAsm"><span class="hs-identifier hs-type">NullAsm</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#instrCount"><span class="hs-identifier hs-var hs-var">instrCount</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068352"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; LabelEnvMap
</span><a href="GHC.ByteCode.Asm.html#lblEnv"><span class="hs-identifier hs-var hs-var">lblEnv</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068352"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-313"></span><span>    </span><span class="annot"><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621681068351"><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068351"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocPtr"><span class="hs-identifier hs-type">AllocPtr</span></a></span><span> </span><span class="annot"><span class="annottext">IO BCOPtr
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621681068350"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068350"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068351"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ptrCount :: Word
</span><a href="GHC.ByteCode.Asm.html#ptrCount"><span class="hs-identifier hs-var">ptrCount</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068349"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Word
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068350"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068349"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-314"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621681068349"><span class="annot"><span class="annottext">n :: Word
</span><a href="#local-6989586621681068349"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#ptrCount"><span class="hs-identifier hs-var hs-var">ptrCount</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068351"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-315"></span><span>    </span><span class="annot"><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621681068347"><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068347"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLit"><span class="hs-identifier hs-type">AllocLit</span></a></span><span> </span><span id="local-6989586621681068346"><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068346"><span class="hs-identifier hs-var">ls</span></a></span></span><span> </span><span id="local-6989586621681068345"><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068345"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068347"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">litCount :: Word
</span><a href="GHC.ByteCode.Asm.html#litCount"><span class="hs-identifier hs-var">litCount</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068344"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Word
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; Word
forall i a. Num i =&gt; [a] -&gt; i
</span><a href="../../base/src/Data.OldList.html#genericLength"><span class="hs-identifier hs-var">genericLength</span></a></span><span> </span><span class="annot"><span class="annottext">[BCONPtr]
</span><a href="#local-6989586621681068346"><span class="hs-identifier hs-var">ls</span></a></span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Assembler a
</span><a href="#local-6989586621681068345"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068344"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-316"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621681068344"><span class="annot"><span class="annottext">n :: Word
</span><a href="#local-6989586621681068344"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#litCount"><span class="hs-identifier hs-var hs-var">litCount</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068347"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-317"></span><span>    </span><span class="annot"><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621681068343"><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068343"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#AllocLabel"><span class="hs-identifier hs-type">AllocLabel</span></a></span><span> </span><span id="local-6989586621681068342"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068342"><span class="hs-identifier hs-var">lbl</span></a></span></span><span> </span><span id="local-6989586621681068341"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068341"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068340"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068341"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-318"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621681068340"><span class="annot"><span class="annottext">s' :: InspectState
</span><a href="#local-6989586621681068340"><span class="hs-identifier hs-var hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068343"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">lblEnv :: LabelEnvMap
</span><a href="GHC.ByteCode.Asm.html#lblEnv"><span class="hs-identifier hs-var">lblEnv</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word -&gt; LabelEnvMap -&gt; LabelEnvMap
forall k a. Ord k =&gt; k -&gt; a -&gt; Map k a -&gt; Map k a
</span><a href="../../containers/src/Data.Map.Internal.html#insert"><span class="hs-identifier hs-var">Map.insert</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068342"><span class="hs-identifier hs-var">lbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#instrCount"><span class="hs-identifier hs-var hs-var">instrCount</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068343"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">InspectState -&gt; LabelEnvMap
</span><a href="GHC.ByteCode.Asm.html#lblEnv"><span class="hs-identifier hs-var hs-var">lblEnv</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068343"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-319"></span><span>    </span><span class="annot"><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621681068337"><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068337"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Emit"><span class="hs-identifier hs-type">Emit</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621681068336"><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068336"><span class="hs-identifier hs-var">ops</span></a></span></span><span> </span><span id="local-6989586621681068335"><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068335"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Assembler a -&gt; (Word, LabelEnvMap)
</span><a href="#local-6989586621681068358"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068334"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="annot"><span class="annottext">Assembler a
</span><a href="#local-6989586621681068335"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-320"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-321"></span><span>        </span><span id="local-6989586621681068334"><span class="annot"><span class="annottext">s' :: InspectState
</span><a href="#local-6989586621681068334"><span class="hs-identifier hs-var hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068337"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">instrCount :: Word
</span><a href="GHC.ByteCode.Asm.html#instrCount"><span class="hs-identifier hs-var">instrCount</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">InspectState -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#instrCount"><span class="hs-identifier hs-var hs-var">instrCount</span></a></span><span> </span><span class="annot"><span class="annottext">InspectState
</span><a href="#local-6989586621681068337"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Word
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068332"><span class="hs-identifier hs-var">size</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-322"></span><span>        </span><span id="local-6989586621681068332"><span class="annot"><span class="annottext">size :: Word
</span><a href="#local-6989586621681068332"><span class="hs-identifier hs-var hs-var">size</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Word
forall (t :: * -&gt; *) a. (Foldable t, Num a) =&gt; t a -&gt; a
</span><a href="../../base/src/Data.Foldable.html#sum"><span class="hs-identifier hs-var">sum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Operand -&gt; Word) -&gt; [Operand] -&gt; [Word]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Operand -&gt; Word
</span><a href="#local-6989586621681068326"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068336"><span class="hs-identifier hs-var">ops</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Word
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">1</span></span><span>
</span><span id="line-323"></span><span>        </span><span id="local-6989586621681068324"><span class="annot"><span class="annottext">largeOps :: Bool
</span><a href="#local-6989586621681068324"><span class="hs-identifier hs-var hs-var">largeOps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Operand -&gt; Bool) -&gt; [Operand] -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; (a -&gt; Bool) -&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#any"><span class="hs-identifier hs-var">any</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; Operand -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#largeOp"><span class="hs-identifier hs-var">largeOp</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068360"><span class="hs-identifier hs-var">long_jumps</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Operand]
</span><a href="#local-6989586621681068336"><span class="hs-identifier hs-var">ops</span></a></span><span>
</span><span id="line-324"></span><span>        </span><span id="local-6989586621681068326"><span class="annot"><span class="annottext">count :: Operand -&gt; Word
</span><a href="#local-6989586621681068326"><span class="hs-identifier hs-var hs-var">count</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#SmallOp"><span class="hs-identifier hs-type">SmallOp</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">1</span></span><span>
</span><span id="line-325"></span><span>        </span><span class="annot"><a href="#local-6989586621681068326"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#LabelOp"><span class="hs-identifier hs-type">LabelOp</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Operand -&gt; Word
</span><a href="#local-6989586621681068326"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Operand
</span><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-var">Op</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-326"></span><span>        </span><span class="annot"><a href="#local-6989586621681068326"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-type">Op</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621681068324"><span class="hs-identifier hs-var">largeOps</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#largeArg16s"><span class="hs-identifier hs-var">largeArg16s</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068361"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">1</span></span><span>
</span><span id="line-327"></span><span class="hs-comment">--      count (LargeOp _) = largeArg16s platform</span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span class="hs-comment">-- Bring in all the bci_ bytecode constants.</span><span class="hs-cpp">
#include &quot;rts/Bytecodes.h&quot;
</span><span>
</span><span id="line-332"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#largeArgInstr"><span class="hs-identifier hs-type">largeArgInstr</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-333"></span><span id="largeArgInstr"><span class="annot"><span class="annottext">largeArgInstr :: Word16 -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#largeArgInstr"><span class="hs-identifier hs-var hs-var">largeArgInstr</span></a></span></span><span> </span><span id="local-6989586621681068320"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068320"><span class="hs-identifier hs-var">bci</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_FLAG_LARGE_ARGS</span><span> </span><span class="hs-operator">.|.</span><span> </span><span class="hs-identifier">bci</span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#largeArg"><span class="hs-identifier hs-type">largeArg</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-336"></span><span id="largeArg"><span class="annot"><span class="annottext">largeArg :: Platform -&gt; Word -&gt; [Word16]
</span><a href="GHC.ByteCode.Asm.html#largeArg"><span class="hs-identifier hs-var hs-var">largeArg</span></a></span></span><span> </span><span id="local-6989586621681068318"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068318"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068317"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#platformWordSize"><span class="hs-identifier hs-var hs-var">platformWordSize</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068318"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-337"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW8"><span class="hs-identifier hs-var">PW8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">48</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-338"></span><span>           </span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">32</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-339"></span><span>           </span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-340"></span><span>           </span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-341"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW4"><span class="hs-identifier hs-var">PW4</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Int -&gt; Word
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-342"></span><span>           </span><span class="annot"><span class="annottext">Word -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068317"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-343"></span><span>
</span><span id="line-344"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#largeArg16s"><span class="hs-identifier hs-type">largeArg16s</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-345"></span><span id="largeArg16s"><span class="annot"><span class="annottext">largeArg16s :: Platform -&gt; Word
</span><a href="GHC.ByteCode.Asm.html#largeArg16s"><span class="hs-identifier hs-var hs-var">largeArg16s</span></a></span></span><span> </span><span id="local-6989586621681068312"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068312"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#platformWordSize"><span class="hs-identifier hs-var hs-var">platformWordSize</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068312"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-346"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW8"><span class="hs-identifier hs-var">PW8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">4</span></span><span>
</span><span id="line-347"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW4"><span class="hs-identifier hs-var">PW4</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">2</span></span><span>
</span><span id="line-348"></span><span>
</span><span id="line-349"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#assembleI"><span class="hs-identifier hs-type">assembleI</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span>
</span><span id="line-350"></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Instr.html#BCInstr"><span class="hs-identifier hs-type">BCInstr</span></a></span><span>
</span><span id="line-351"></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.ByteCode.Asm.html#Assembler"><span class="hs-identifier hs-type">Assembler</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-352"></span><span id="assembleI"><span class="annot"><span class="annottext">assembleI :: Platform -&gt; BCInstr -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#assembleI"><span class="hs-identifier hs-var hs-var">assembleI</span></a></span></span><span> </span><span id="local-6989586621681068311"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068310"><span class="annot"><span class="annottext">BCInstr
</span><a href="#local-6989586621681068310"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">BCInstr
</span><a href="#local-6989586621681068310"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-353"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#STKCHECK"><span class="hs-identifier hs-type">STKCHECK</span></a></span><span> </span><span id="local-6989586621681068308"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068308"><span class="hs-identifier hs-var">n</span></a></span></span><span>               </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_STKCHECK</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-354"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_L"><span class="hs-identifier hs-type">PUSH_L</span></a></span><span> </span><span id="local-6989586621681068306"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068306"><span class="hs-identifier hs-var">o1</span></a></span></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_L</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-355"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_LL"><span class="hs-identifier hs-type">PUSH_LL</span></a></span><span> </span><span id="local-6989586621681068304"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068304"><span class="hs-identifier hs-var">o1</span></a></span></span><span> </span><span id="local-6989586621681068303"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068303"><span class="hs-identifier hs-var">o2</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_LL</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o2</span><span class="hs-special">]</span><span>
</span><span id="line-356"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_LLL"><span class="hs-identifier hs-type">PUSH_LLL</span></a></span><span> </span><span id="local-6989586621681068301"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068301"><span class="hs-identifier hs-var">o1</span></a></span></span><span> </span><span id="local-6989586621681068300"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068300"><span class="hs-identifier hs-var">o2</span></a></span></span><span> </span><span id="local-6989586621681068299"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068299"><span class="hs-identifier hs-var">o3</span></a></span></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_LLL</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o2</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o3</span><span class="hs-special">]</span><span>
</span><span id="line-357"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH8"><span class="hs-identifier hs-type">PUSH8</span></a></span><span> </span><span id="local-6989586621681068297"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068297"><span class="hs-identifier hs-var">o1</span></a></span></span><span>                 </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH8</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-358"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH16"><span class="hs-identifier hs-type">PUSH16</span></a></span><span> </span><span id="local-6989586621681068295"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068295"><span class="hs-identifier hs-var">o1</span></a></span></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH16</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-359"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH32"><span class="hs-identifier hs-type">PUSH32</span></a></span><span> </span><span id="local-6989586621681068293"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068293"><span class="hs-identifier hs-var">o1</span></a></span></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH32</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-360"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH8_W"><span class="hs-identifier hs-type">PUSH8_W</span></a></span><span> </span><span id="local-6989586621681068291"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068291"><span class="hs-identifier hs-var">o1</span></a></span></span><span>               </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH8_W</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-361"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH16_W"><span class="hs-identifier hs-type">PUSH16_W</span></a></span><span> </span><span id="local-6989586621681068289"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068289"><span class="hs-identifier hs-var">o1</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH16_W</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-362"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH32_W"><span class="hs-identifier hs-type">PUSH32_W</span></a></span><span> </span><span id="local-6989586621681068287"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068287"><span class="hs-identifier hs-var">o1</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH32_W</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">o1</span><span class="hs-special">]</span><span>
</span><span id="line-363"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_G"><span class="hs-identifier hs-type">PUSH_G</span></a></span><span> </span><span id="local-6989586621681068285"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068285"><span class="hs-identifier hs-var">nm</span></a></span></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068284"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068284"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ptr"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrName"><span class="hs-identifier hs-var">BCOPtrName</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621681068285"><span class="hs-identifier hs-var">nm</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-364"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_G</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">p</span><span class="hs-special">]</span><span>
</span><span id="line-365"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_PRIMOP"><span class="hs-identifier hs-type">PUSH_PRIMOP</span></a></span><span> </span><span id="local-6989586621681068282"><span class="annot"><span class="annottext">PrimOp
</span><a href="#local-6989586621681068282"><span class="hs-identifier hs-var">op</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068281"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068281"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ptr"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">PrimOp -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrPrimOp"><span class="hs-identifier hs-var">BCOPtrPrimOp</span></a></span><span> </span><span class="annot"><span class="annottext">PrimOp
</span><a href="#local-6989586621681068282"><span class="hs-identifier hs-var">op</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-366"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_G</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">p</span><span class="hs-special">]</span><span>
</span><span id="line-367"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_BCO"><span class="hs-identifier hs-type">PUSH_BCO</span></a></span><span> </span><span id="local-6989586621681068278"><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068278"><span class="hs-identifier hs-var">proto</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068277"><span class="annot"><span class="annottext">ul_bco :: IO UnlinkedBCO
</span><a href="#local-6989586621681068277"><span class="hs-identifier hs-var hs-var">ul_bco</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var">assembleBCO</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068278"><span class="hs-identifier hs-var">proto</span></a></span><span>
</span><span id="line-368"></span><span>                                 </span><span id="local-6989586621681068276"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068276"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-var">ioptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; BCOPtr) -&gt; IO UnlinkedBCO -&gt; IO BCOPtr
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-var">BCOPtrBCO</span></a></span><span> </span><span class="annot"><span class="annottext">IO UnlinkedBCO
</span><a href="#local-6989586621681068277"><span class="hs-identifier hs-var">ul_bco</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-369"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_G</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">p</span><span class="hs-special">]</span><span>
</span><span id="line-370"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_ALTS"><span class="hs-identifier hs-type">PUSH_ALTS</span></a></span><span> </span><span id="local-6989586621681068273"><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068273"><span class="hs-identifier hs-var">proto</span></a></span></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068272"><span class="annot"><span class="annottext">ul_bco :: IO UnlinkedBCO
</span><a href="#local-6989586621681068272"><span class="hs-identifier hs-var hs-var">ul_bco</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var">assembleBCO</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068273"><span class="hs-identifier hs-var">proto</span></a></span><span>
</span><span id="line-371"></span><span>                                 </span><span id="local-6989586621681068271"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068271"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-var">ioptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; BCOPtr) -&gt; IO UnlinkedBCO -&gt; IO BCOPtr
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-var">BCOPtrBCO</span></a></span><span> </span><span class="annot"><span class="annottext">IO UnlinkedBCO
</span><a href="#local-6989586621681068272"><span class="hs-identifier hs-var">ul_bco</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-372"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_ALTS</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">p</span><span class="hs-special">]</span><span>
</span><span id="line-373"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_ALTS_UNLIFTED"><span class="hs-identifier hs-type">PUSH_ALTS_UNLIFTED</span></a></span><span> </span><span id="local-6989586621681068269"><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068269"><span class="hs-identifier hs-var">proto</span></a></span></span><span> </span><span id="local-6989586621681068268"><span class="annot"><span class="annottext">ArgRep
</span><a href="#local-6989586621681068268"><span class="hs-identifier hs-var">pk</span></a></span></span><span>
</span><span id="line-374"></span><span>                           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621681068267"><span class="annot"><span class="annottext">ul_bco :: IO UnlinkedBCO
</span><a href="#local-6989586621681068267"><span class="hs-identifier hs-var hs-var">ul_bco</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; ProtoBCO Name -&gt; IO UnlinkedBCO
</span><a href="GHC.ByteCode.Asm.html#assembleBCO"><span class="hs-identifier hs-var">assembleBCO</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">ProtoBCO Name
</span><a href="#local-6989586621681068269"><span class="hs-identifier hs-var">proto</span></a></span><span>
</span><span id="line-375"></span><span>                                 </span><span id="local-6989586621681068266"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068266"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ioptr"><span class="hs-identifier hs-var">ioptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(UnlinkedBCO -&gt; BCOPtr) -&gt; IO UnlinkedBCO -&gt; IO BCOPtr
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">UnlinkedBCO -&gt; BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrBCO"><span class="hs-identifier hs-var">BCOPtrBCO</span></a></span><span> </span><span class="annot"><span class="annottext">IO UnlinkedBCO
</span><a href="#local-6989586621681068267"><span class="hs-identifier hs-var">ul_bco</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-376"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ArgRep -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="#local-6989586621681068268"><span class="hs-identifier hs-var">pk</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word -&gt; Operand
</span><a href="GHC.ByteCode.Asm.html#Op"><span class="hs-identifier hs-var">Op</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068266"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-377"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_PAD8"><span class="hs-identifier hs-var">PUSH_PAD8</span></a></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_PAD8</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-378"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_PAD16"><span class="hs-identifier hs-var">PUSH_PAD16</span></a></span><span>               </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_PAD16</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-379"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_PAD32"><span class="hs-identifier hs-var">PUSH_PAD32</span></a></span><span>               </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_PAD32</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-380"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_UBX8"><span class="hs-identifier hs-type">PUSH_UBX8</span></a></span><span> </span><span id="local-6989586621681068260"><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068260"><span class="hs-identifier hs-var">lit</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068259"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068259"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Literal -&gt; Assembler Word
</span><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068260"><span class="hs-identifier hs-var">lit</span></a></span><span>
</span><span id="line-381"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_UBX8</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">]</span><span>
</span><span id="line-382"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_UBX16"><span class="hs-identifier hs-type">PUSH_UBX16</span></a></span><span> </span><span id="local-6989586621681068256"><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068256"><span class="hs-identifier hs-var">lit</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068255"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068255"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Literal -&gt; Assembler Word
</span><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068256"><span class="hs-identifier hs-var">lit</span></a></span><span>
</span><span id="line-383"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_UBX16</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">]</span><span>
</span><span id="line-384"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_UBX32"><span class="hs-identifier hs-type">PUSH_UBX32</span></a></span><span> </span><span id="local-6989586621681068253"><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068253"><span class="hs-identifier hs-var">lit</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068252"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068252"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Literal -&gt; Assembler Word
</span><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068253"><span class="hs-identifier hs-var">lit</span></a></span><span>
</span><span id="line-385"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_UBX32</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">]</span><span>
</span><span id="line-386"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PUSH_UBX"><span class="hs-identifier hs-type">PUSH_UBX</span></a></span><span> </span><span id="local-6989586621681068250"><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068250"><span class="hs-identifier hs-var">lit</span></a></span></span><span> </span><span id="local-6989586621681068249"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068249"><span class="hs-identifier hs-var">nws</span></a></span></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068248"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068248"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Literal -&gt; Assembler Word
</span><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="#local-6989586621681068250"><span class="hs-identifier hs-var">lit</span></a></span><span>
</span><span id="line-387"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_UBX</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">nws</span><span class="hs-special">]</span><span>
</span><span id="line-388"></span><span>
</span><span id="line-389"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_N"><span class="hs-identifier hs-var">PUSH_APPLY_N</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_N</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-390"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_V"><span class="hs-identifier hs-var">PUSH_APPLY_V</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_V</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-391"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_F"><span class="hs-identifier hs-var">PUSH_APPLY_F</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_F</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-392"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_D"><span class="hs-identifier hs-var">PUSH_APPLY_D</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_D</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-393"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_L"><span class="hs-identifier hs-var">PUSH_APPLY_L</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_L</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-394"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_P"><span class="hs-identifier hs-var">PUSH_APPLY_P</span></a></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_P</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-395"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_PP"><span class="hs-identifier hs-var">PUSH_APPLY_PP</span></a></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_PP</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-396"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_PPP"><span class="hs-identifier hs-var">PUSH_APPLY_PPP</span></a></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_PPP</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-397"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_PPPP"><span class="hs-identifier hs-var">PUSH_APPLY_PPPP</span></a></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_PPPP</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-398"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_PPPPP"><span class="hs-identifier hs-var">PUSH_APPLY_PPPPP</span></a></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_PPPPP</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-399"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#PUSH_APPLY_PPPPPP"><span class="hs-identifier hs-var">PUSH_APPLY_PPPPPP</span></a></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PUSH_APPLY_PPPPPP</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-400"></span><span>
</span><span id="line-401"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#SLIDE"><span class="hs-identifier hs-type">SLIDE</span></a></span><span>     </span><span id="local-6989586621681068235"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068235"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621681068234"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068234"><span class="hs-identifier hs-var">by</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_SLIDE</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">by</span><span class="hs-special">]</span><span>
</span><span id="line-402"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#ALLOC_AP"><span class="hs-identifier hs-type">ALLOC_AP</span></a></span><span>  </span><span id="local-6989586621681068232"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068232"><span class="hs-identifier hs-var">n</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_ALLOC_AP</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-403"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#ALLOC_AP_NOUPD"><span class="hs-identifier hs-type">ALLOC_AP_NOUPD</span></a></span><span> </span><span id="local-6989586621681068230"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068230"><span class="hs-identifier hs-var">n</span></a></span></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_ALLOC_AP_NOUPD</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-404"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#ALLOC_PAP"><span class="hs-identifier hs-type">ALLOC_PAP</span></a></span><span> </span><span id="local-6989586621681068228"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068228"><span class="hs-identifier hs-var">arity</span></a></span></span><span> </span><span id="local-6989586621681068227"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068227"><span class="hs-identifier hs-var">n</span></a></span></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_ALLOC_PAP</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">arity</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-405"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#MKAP"><span class="hs-identifier hs-type">MKAP</span></a></span><span>      </span><span id="local-6989586621681068225"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068225"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621681068224"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068224"><span class="hs-identifier hs-var">sz</span></a></span></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_MKAP</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">off</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">sz</span><span class="hs-special">]</span><span>
</span><span id="line-406"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#MKPAP"><span class="hs-identifier hs-type">MKPAP</span></a></span><span>     </span><span id="local-6989586621681068222"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068222"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621681068221"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068221"><span class="hs-identifier hs-var">sz</span></a></span></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_MKPAP</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">off</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">sz</span><span class="hs-special">]</span><span>
</span><span id="line-407"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#UNPACK"><span class="hs-identifier hs-type">UNPACK</span></a></span><span>    </span><span id="local-6989586621681068219"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068219"><span class="hs-identifier hs-var">n</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_UNPACK</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-408"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#PACK"><span class="hs-identifier hs-type">PACK</span></a></span><span>      </span><span id="local-6989586621681068217"><span class="annot"><span class="annottext">DataCon
</span><a href="#local-6989586621681068217"><span class="hs-identifier hs-var">dcon</span></a></span></span><span> </span><span id="local-6989586621681068216"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068216"><span class="hs-identifier hs-var">sz</span></a></span></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068215"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068215"><span class="hs-identifier hs-var">itbl_no</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-var">lit</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Name -&gt; BCONPtr
</span><a href="GHC.ByteCode.Types.html#BCONPtrItbl"><span class="hs-identifier hs-var">BCONPtrItbl</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DataCon -&gt; Name
forall a. NamedThing a =&gt; a -&gt; Name
</span><a href="GHC.Types.Name.html#getName"><span class="hs-identifier hs-var">getName</span></a></span><span> </span><span class="annot"><span class="annottext">DataCon
</span><a href="#local-6989586621681068217"><span class="hs-identifier hs-var">dcon</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-409"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_PACK</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">itbl_no</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">sz</span><span class="hs-special">]</span><span>
</span><span id="line-410"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#LABEL"><span class="hs-identifier hs-type">LABEL</span></a></span><span>     </span><span id="local-6989586621681068212"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068212"><span class="hs-identifier hs-var">lbl</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#label"><span class="hs-keyword hs-var">label</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068212"><span class="hs-identifier hs-var">lbl</span></a></span><span>
</span><span id="line-411"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTLT_I"><span class="hs-identifier hs-type">TESTLT_I</span></a></span><span>  </span><span id="local-6989586621681068210"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068210"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621681068209"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068209"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068208"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068208"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068210"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-412"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTLT_I</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-413"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTEQ_I"><span class="hs-identifier hs-type">TESTEQ_I</span></a></span><span>  </span><span id="local-6989586621681068205"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068205"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621681068204"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068204"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068203"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068203"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068205"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-414"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTEQ_I</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-415"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTLT_W"><span class="hs-identifier hs-type">TESTLT_W</span></a></span><span>  </span><span id="local-6989586621681068201"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068201"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span id="local-6989586621681068200"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068200"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068199"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068199"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler Word
</span><a href="#local-6989586621681068198"><span class="hs-identifier hs-var">word</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068201"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-416"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTLT_W</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-417"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTEQ_W"><span class="hs-identifier hs-type">TESTEQ_W</span></a></span><span>  </span><span id="local-6989586621681068196"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068196"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span id="local-6989586621681068195"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068195"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068194"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068194"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word -&gt; Assembler Word
</span><a href="#local-6989586621681068198"><span class="hs-identifier hs-var">word</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068196"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-418"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTEQ_W</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-419"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTLT_F"><span class="hs-identifier hs-type">TESTLT_F</span></a></span><span>  </span><span id="local-6989586621681068192"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068192"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621681068191"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068191"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068190"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068190"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Float -&gt; Assembler Word
</span><a href="#local-6989586621681068189"><span class="hs-identifier hs-var">float</span></a></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068192"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-420"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTLT_F</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-421"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTEQ_F"><span class="hs-identifier hs-type">TESTEQ_F</span></a></span><span>  </span><span id="local-6989586621681068187"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068187"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621681068186"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068186"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068185"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068185"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Float -&gt; Assembler Word
</span><a href="#local-6989586621681068189"><span class="hs-identifier hs-var">float</span></a></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068187"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-422"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTEQ_F</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-423"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTLT_D"><span class="hs-identifier hs-type">TESTLT_D</span></a></span><span>  </span><span id="local-6989586621681068183"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068183"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621681068182"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068182"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068181"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068181"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Double -&gt; Assembler Word
</span><a href="#local-6989586621681068180"><span class="hs-identifier hs-var">double</span></a></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068183"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-424"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTLT_D</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-425"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTEQ_D"><span class="hs-identifier hs-type">TESTEQ_D</span></a></span><span>  </span><span id="local-6989586621681068178"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068178"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621681068177"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068177"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068176"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068176"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Double -&gt; Assembler Word
</span><a href="#local-6989586621681068180"><span class="hs-identifier hs-var">double</span></a></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068178"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-426"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTEQ_D</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-427"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTLT_P"><span class="hs-identifier hs-type">TESTLT_P</span></a></span><span>  </span><span id="local-6989586621681068174"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068174"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621681068173"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068173"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTLT_P</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">i</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-428"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#TESTEQ_P"><span class="hs-identifier hs-type">TESTEQ_P</span></a></span><span>  </span><span id="local-6989586621681068171"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068171"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621681068170"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068170"><span class="hs-identifier hs-var">l</span></a></span></span><span>            </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_TESTEQ_P</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">i</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-429"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#CASEFAIL"><span class="hs-identifier hs-var">CASEFAIL</span></a></span><span>                 </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_CASEFAIL</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-430"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#SWIZZLE"><span class="hs-identifier hs-type">SWIZZLE</span></a></span><span>   </span><span id="local-6989586621681068167"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068167"><span class="hs-identifier hs-var">stkoff</span></a></span></span><span> </span><span id="local-6989586621681068166"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068166"><span class="hs-identifier hs-var">n</span></a></span></span><span>       </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_SWIZZLE</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">stkoff</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">n</span><span class="hs-special">]</span><span>
</span><span id="line-431"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#JMP"><span class="hs-identifier hs-type">JMP</span></a></span><span>       </span><span id="local-6989586621681068164"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068164"><span class="hs-identifier hs-var">l</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_JMP</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">LabelOp</span><span> </span><span class="hs-identifier">l</span><span class="hs-special">]</span><span>
</span><span id="line-432"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#ENTER"><span class="hs-identifier hs-var">ENTER</span></a></span><span>                    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_ENTER</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-433"></span><span>  </span><span class="annot"><span class="annottext">BCInstr
</span><a href="GHC.ByteCode.Instr.html#RETURN"><span class="hs-identifier hs-var">RETURN</span></a></span><span>                   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_RETURN</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-434"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#RETURN_UBX"><span class="hs-identifier hs-type">RETURN_UBX</span></a></span><span> </span><span id="local-6989586621681068160"><span class="annot"><span class="annottext">ArgRep
</span><a href="#local-6989586621681068160"><span class="hs-identifier hs-var">rep</span></a></span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ArgRep -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="#local-6989586621681068160"><span class="hs-identifier hs-var">rep</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-435"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#CCALL"><span class="hs-identifier hs-type">CCALL</span></a></span><span> </span><span id="local-6989586621681068157"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068157"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621681068156"><span class="annot"><span class="annottext">RemotePtr C_ffi_cif
</span><a href="#local-6989586621681068156"><span class="hs-identifier hs-var">m_addr</span></a></span></span><span> </span><span id="local-6989586621681068155"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068155"><span class="hs-identifier hs-var">i</span></a></span></span><span>       </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068154"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068154"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">RemotePtr C_ffi_cif -&gt; Assembler Word
forall {a}. RemotePtr a -&gt; Assembler Word
</span><a href="#local-6989586621681068153"><span class="hs-identifier hs-var">addr</span></a></span><span> </span><span class="annot"><span class="annottext">RemotePtr C_ffi_cif
</span><a href="#local-6989586621681068156"><span class="hs-identifier hs-var">m_addr</span></a></span><span>
</span><span id="line-436"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_CCALL</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">off</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">i</span><span class="hs-special">]</span><span>
</span><span id="line-437"></span><span>  </span><span class="annot"><a href="GHC.ByteCode.Instr.html#BRK_FUN"><span class="hs-identifier hs-type">BRK_FUN</span></a></span><span> </span><span id="local-6989586621681068151"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621681068151"><span class="hs-identifier hs-var">index</span></a></span></span><span> </span><span id="local-6989586621681068150"><span class="annot"><span class="annottext">Unique
</span><a href="#local-6989586621681068150"><span class="hs-identifier hs-var">uniq</span></a></span></span><span> </span><span id="local-6989586621681068149"><span class="annot"><span class="annottext">RemotePtr CostCentre
</span><a href="#local-6989586621681068149"><span class="hs-identifier hs-var">cc</span></a></span></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621681068148"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068148"><span class="hs-identifier hs-var">p1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BCOPtr -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#ptr"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="annot"><span class="annottext">BCOPtr
</span><a href="GHC.ByteCode.Types.html#BCOPtrBreakArray"><span class="hs-identifier hs-var">BCOPtrBreakArray</span></a></span><span>
</span><span id="line-438"></span><span>                                 </span><span id="local-6989586621681068146"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068146"><span class="hs-identifier hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Unique -&gt; Int
</span><a href="GHC.Types.Unique.html#getKey"><span class="hs-identifier hs-var">getKey</span></a></span><span> </span><span class="annot"><span class="annottext">Unique
</span><a href="#local-6989586621681068150"><span class="hs-identifier hs-var">uniq</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-439"></span><span>                                 </span><span id="local-6989586621681068144"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068144"><span class="hs-identifier hs-var">np</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">RemotePtr CostCentre -&gt; Assembler Word
forall {a}. RemotePtr a -&gt; Assembler Word
</span><a href="#local-6989586621681068153"><span class="hs-identifier hs-var">addr</span></a></span><span> </span><span class="annot"><span class="annottext">RemotePtr CostCentre
</span><a href="#local-6989586621681068149"><span class="hs-identifier hs-var">cc</span></a></span><span>
</span><span id="line-440"></span><span>                                 </span><span class="annot"><span class="annottext">Word16 -&gt; [Operand] -&gt; Assembler ()
</span><a href="GHC.ByteCode.Asm.html#emit"><span class="hs-identifier hs-var">emit</span></a></span><span> </span><span class="hs-identifier">bci_BRK_FUN</span><span> </span><span class="hs-special">[</span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">p1</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">SmallOp</span><span> </span><span class="hs-identifier">index</span><span class="hs-special">,</span><span>
</span><span id="line-441"></span><span>                                                   </span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">q</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">Op</span><span> </span><span class="hs-identifier">np</span><span class="hs-special">]</span><span>
</span><span id="line-442"></span><span>
</span><span id="line-443"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-444"></span><span>    </span><span id="local-6989586621681068258"><span class="annot"><span class="annottext">literal :: Literal -&gt; Assembler Word
</span><a href="#local-6989586621681068258"><span class="hs-identifier hs-var hs-var">literal</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitLabel"><span class="hs-identifier hs-type">LitLabel</span></a></span><span> </span><span id="local-6989586621681068124"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068124"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621681068123"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068123"><span class="hs-identifier hs-var">sz</span></a></span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span>
</span><span id="line-445"></span><span>     </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; OS
</span><a href="../../ghc-boot/src/GHC.Platform.html#platformOS"><span class="hs-identifier hs-var">platformOS</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="annot"><span class="annottext">OS -&gt; OS -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">OS
</span><a href="../../ghc-boot/src/GHC.Platform.html#OSMinGW32"><span class="hs-identifier hs-var">OSMinGW32</span></a></span><span>
</span><span id="line-446"></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Assembler Word
</span><a href="#local-6989586621681068120"><span class="hs-identifier hs-var">litlabel</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; FastString -&gt; FastString
</span><a href="GHC.Data.FastString.html#appendFS"><span class="hs-identifier hs-var">appendFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068124"><span class="hs-identifier hs-var">fs</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#mkFastString"><span class="hs-identifier hs-var">mkFastString</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'@'</span></span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681068123"><span class="hs-identifier hs-var">sz</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-447"></span><span>     </span><span class="hs-comment">-- On Windows, stdcall labels have a suffix indicating the no. of</span><span>
</span><span id="line-448"></span><span>     </span><span class="hs-comment">-- arg words, e.g. foo@8.  testcase: ffi012(ghci)</span><span>
</span><span id="line-449"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitLabel"><span class="hs-identifier hs-type">LitLabel</span></a></span><span> </span><span id="local-6989586621681068116"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068116"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="annot"><span class="annottext">Maybe Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Assembler Word
</span><a href="#local-6989586621681068120"><span class="hs-identifier hs-var">litlabel</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068116"><span class="hs-identifier hs-var">fs</span></a></span><span>
</span><span id="line-450"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="GHC.Types.Literal.html#LitNullAddr"><span class="hs-identifier hs-var">LitNullAddr</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-451"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitFloat"><span class="hs-identifier hs-type">LitFloat</span></a></span><span> </span><span id="local-6989586621681068113"><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621681068113"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Float -&gt; Assembler Word
</span><a href="#local-6989586621681068189"><span class="hs-identifier hs-var">float</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rational -&gt; Float
forall a. Fractional a =&gt; Rational -&gt; a
</span><a href="../../base/src/GHC.Real.html#fromRational"><span class="hs-identifier hs-var">fromRational</span></a></span><span> </span><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621681068113"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-452"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitDouble"><span class="hs-identifier hs-type">LitDouble</span></a></span><span> </span><span id="local-6989586621681068111"><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621681068111"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Double -&gt; Assembler Word
</span><a href="#local-6989586621681068180"><span class="hs-identifier hs-var">double</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rational -&gt; Double
forall a. Fractional a =&gt; Rational -&gt; a
</span><a href="../../base/src/GHC.Real.html#fromRational"><span class="hs-identifier hs-var">fromRational</span></a></span><span> </span><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621681068111"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-453"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitChar"><span class="hs-identifier hs-type">LitChar</span></a></span><span> </span><span id="local-6989586621681068109"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621681068109"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">)</span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Int
</span><a href="../../base/src/GHC.Base.html#ord"><span class="hs-identifier hs-var">ord</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621681068109"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-454"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitString"><span class="hs-identifier hs-type">LitString</span></a></span><span> </span><span id="local-6989586621681068107"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621681068107"><span class="hs-identifier hs-var">bs</span></a></span></span><span class="hs-special">)</span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-var">lit</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">ByteString -&gt; BCONPtr
</span><a href="GHC.ByteCode.Types.html#BCONPtrStr"><span class="hs-identifier hs-var">BCONPtrStr</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621681068107"><span class="hs-identifier hs-var">bs</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-455"></span><span>       </span><span class="hs-comment">-- LitString requires a zero-terminator when emitted</span><span>
</span><span id="line-456"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Literal.html#LitNumber"><span class="hs-identifier hs-type">LitNumber</span></a></span><span> </span><span id="local-6989586621681068105"><span class="annot"><span class="annottext">LitNumType
</span><a href="#local-6989586621681068105"><span class="hs-identifier hs-var">nt</span></a></span></span><span> </span><span id="local-6989586621681068104"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621681068104"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">LitNumType
</span><a href="#local-6989586621681068105"><span class="hs-identifier hs-var">nt</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-457"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumInt"><span class="hs-identifier hs-var">LitNumInt</span></a></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621681068104"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-458"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumWord"><span class="hs-identifier hs-var">LitNumWord</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621681068104"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-459"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumInt64"><span class="hs-identifier hs-var">LitNumInt64</span></a></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Assembler Word
</span><a href="#local-6989586621681068100"><span class="hs-identifier hs-var">int64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621681068104"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-460"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumWord64"><span class="hs-identifier hs-var">LitNumWord64</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Assembler Word
</span><a href="#local-6989586621681068100"><span class="hs-identifier hs-var">int64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621681068104"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-461"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumInteger"><span class="hs-identifier hs-var">LitNumInteger</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Assembler Word
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHC.ByteCode.Asm.literal: LitNumInteger&quot;</span></span><span>
</span><span id="line-462"></span><span>      </span><span class="annot"><span class="annottext">LitNumType
</span><a href="GHC.Types.Literal.html#LitNumNatural"><span class="hs-identifier hs-var">LitNumNatural</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Assembler Word
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHC.ByteCode.Asm.literal: LitNumNatural&quot;</span></span><span>
</span><span id="line-463"></span><span>    </span><span class="hs-comment">-- We can lower 'LitRubbish' to an arbitrary constant, but @NULL@ is most</span><span>
</span><span id="line-464"></span><span>    </span><span class="hs-comment">-- likely to elicit a crash (rather than corrupt memory) in case absence</span><span>
</span><span id="line-465"></span><span>    </span><span class="hs-comment">-- analysis messed up.</span><span>
</span><span id="line-466"></span><span>    </span><span class="annot"><a href="#local-6989586621681068258"><span class="hs-identifier hs-var">literal</span></a></span><span> </span><span class="annot"><span class="annottext">Literal
</span><a href="GHC.Types.Literal.html#LitRubbish"><span class="hs-identifier hs-var">LitRubbish</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-467"></span><span>
</span><span id="line-468"></span><span>    </span><span id="local-6989586621681068120"><span class="annot"><span class="annottext">litlabel :: FastString -&gt; Assembler Word
</span><a href="#local-6989586621681068120"><span class="hs-identifier hs-var hs-var">litlabel</span></a></span></span><span> </span><span id="local-6989586621681068095"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068095"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-var">lit</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">FastString -&gt; BCONPtr
</span><a href="GHC.ByteCode.Types.html#BCONPtrLbl"><span class="hs-identifier hs-var">BCONPtrLbl</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621681068095"><span class="hs-identifier hs-var">fs</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-469"></span><span>    </span><span id="local-6989586621681068153"><span class="annot"><span class="annottext">addr :: RemotePtr a -&gt; Assembler Word
</span><a href="#local-6989586621681068153"><span class="hs-identifier hs-var hs-var">addr</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghci/src/GHCi.RemoteTypes.html#RemotePtr"><span class="hs-identifier hs-type">RemotePtr</span></a></span><span> </span><span id="local-6989586621681068091"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621681068091"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word64 -&gt; Word
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621681068091"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-470"></span><span>    </span><span id="local-6989586621681068189"><span class="annot"><span class="annottext">float :: Float -&gt; Assembler Word
</span><a href="#local-6989586621681068189"><span class="hs-identifier hs-var hs-var">float</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="annot"><span class="annottext">([Word] -&gt; Assembler Word)
-&gt; (Float -&gt; [Word]) -&gt; Float -&gt; Assembler Word
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Float -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitF"><span class="hs-identifier hs-var">mkLitF</span></a></span><span>
</span><span id="line-471"></span><span>    </span><span id="local-6989586621681068180"><span class="annot"><span class="annottext">double :: Double -&gt; Assembler Word
</span><a href="#local-6989586621681068180"><span class="hs-identifier hs-var hs-var">double</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="annot"><span class="annottext">([Word] -&gt; Assembler Word)
-&gt; (Double -&gt; [Word]) -&gt; Double -&gt; Assembler Word
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Platform -&gt; Double -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitD"><span class="hs-identifier hs-var">mkLitD</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span>
</span><span id="line-472"></span><span>    </span><span id="local-6989586621681068207"><span class="annot"><span class="annottext">int :: Int -&gt; Assembler Word
</span><a href="#local-6989586621681068207"><span class="hs-identifier hs-var hs-var">int</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="annot"><span class="annottext">([Word] -&gt; Assembler Word)
-&gt; (Int -&gt; [Word]) -&gt; Int -&gt; Assembler Word
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitI"><span class="hs-identifier hs-var">mkLitI</span></a></span><span>
</span><span id="line-473"></span><span>    </span><span id="local-6989586621681068100"><span class="annot"><span class="annottext">int64 :: Int64 -&gt; Assembler Word
</span><a href="#local-6989586621681068100"><span class="hs-identifier hs-var hs-var">int64</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="annot"><span class="annottext">([Word] -&gt; Assembler Word)
-&gt; (Int64 -&gt; [Word]) -&gt; Int64 -&gt; Assembler Word
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Platform -&gt; Int64 -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitI64"><span class="hs-identifier hs-var">mkLitI64</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068311"><span class="hs-identifier hs-var">platform</span></a></span><span>
</span><span id="line-474"></span><span>    </span><span id="local-6989586621681068090"><span class="annot"><span class="annottext">words :: [Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var hs-var">words</span></a></span></span><span> </span><span id="local-6989586621681068085"><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621681068085"><span class="hs-identifier hs-var">ws</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[BCONPtr] -&gt; Assembler Word
</span><a href="GHC.ByteCode.Asm.html#lit"><span class="hs-identifier hs-var">lit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Word -&gt; BCONPtr) -&gt; [Word] -&gt; [BCONPtr]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; BCONPtr
</span><a href="GHC.ByteCode.Types.html#BCONPtrWord"><span class="hs-identifier hs-var">BCONPtrWord</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621681068085"><span class="hs-identifier hs-var">ws</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-475"></span><span>    </span><span id="local-6989586621681068198"><span class="annot"><span class="annottext">word :: Word -&gt; Assembler Word
</span><a href="#local-6989586621681068198"><span class="hs-identifier hs-var hs-var">word</span></a></span></span><span> </span><span id="local-6989586621681068084"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068084"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word] -&gt; Assembler Word
</span><a href="#local-6989586621681068090"><span class="hs-identifier hs-var">words</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068084"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-476"></span><span>
</span><span id="line-477"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#isLarge"><span class="hs-identifier hs-type">isLarge</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span>
</span><span id="line-478"></span><span id="isLarge"><span class="annot"><span class="annottext">isLarge :: Word -&gt; Bool
</span><a href="GHC.ByteCode.Asm.html#isLarge"><span class="hs-identifier hs-var hs-var">isLarge</span></a></span></span><span> </span><span id="local-6989586621681068083"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068083"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068083"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Word
</span><span class="hs-number">65535</span></span><span>
</span><span id="line-479"></span><span>
</span><span id="line-480"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-type">push_alts</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.StgToCmm.ArgRep.html#ArgRep"><span class="hs-identifier hs-type">ArgRep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-481"></span><span id="push_alts"><span class="annot"><span class="annottext">push_alts :: ArgRep -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var hs-var">push_alts</span></a></span></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V"><span class="hs-identifier hs-var">V</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_V</span><span>
</span><span id="line-482"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#P"><span class="hs-identifier hs-var">P</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_P</span><span>
</span><span id="line-483"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#N"><span class="hs-identifier hs-var">N</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_N</span><span>
</span><span id="line-484"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#L"><span class="hs-identifier hs-var">L</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_L</span><span>
</span><span id="line-485"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#F"><span class="hs-identifier hs-var">F</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_F</span><span>
</span><span id="line-486"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#D"><span class="hs-identifier hs-var">D</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_PUSH_ALTS_D</span><span>
</span><span id="line-487"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V16"><span class="hs-identifier hs-var">V16</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;push_alts: vector&quot;</span></span><span>
</span><span id="line-488"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V32"><span class="hs-identifier hs-var">V32</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;push_alts: vector&quot;</span></span><span>
</span><span id="line-489"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#push_alts"><span class="hs-identifier hs-var">push_alts</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V64"><span class="hs-identifier hs-var">V64</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;push_alts: vector&quot;</span></span><span>
</span><span id="line-490"></span><span>
</span><span id="line-491"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-type">return_ubx</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.StgToCmm.ArgRep.html#ArgRep"><span class="hs-identifier hs-type">ArgRep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-492"></span><span id="return_ubx"><span class="annot"><span class="annottext">return_ubx :: ArgRep -&gt; Word16
</span><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var hs-var">return_ubx</span></a></span></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V"><span class="hs-identifier hs-var">V</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_V</span><span>
</span><span id="line-493"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#P"><span class="hs-identifier hs-var">P</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_P</span><span>
</span><span id="line-494"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#N"><span class="hs-identifier hs-var">N</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_N</span><span>
</span><span id="line-495"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#L"><span class="hs-identifier hs-var">L</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_L</span><span>
</span><span id="line-496"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#F"><span class="hs-identifier hs-var">F</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_F</span><span>
</span><span id="line-497"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#D"><span class="hs-identifier hs-var">D</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">bci_RETURN_D</span><span>
</span><span id="line-498"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V16"><span class="hs-identifier hs-var">V16</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;return_ubx: vector&quot;</span></span><span>
</span><span id="line-499"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V32"><span class="hs-identifier hs-var">V32</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;return_ubx: vector&quot;</span></span><span>
</span><span id="line-500"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#return_ubx"><span class="hs-identifier hs-var">return_ubx</span></a></span><span> </span><span class="annot"><span class="annottext">ArgRep
</span><a href="GHC.StgToCmm.ArgRep.html#V64"><span class="hs-identifier hs-var">V64</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Word16
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;return_ubx: vector&quot;</span></span><span>
</span><span id="line-501"></span><span>
</span><span id="line-502"></span><span class="hs-comment">-- Make lists of host-sized words for literals, so that when the</span><span>
</span><span id="line-503"></span><span class="hs-comment">-- words are placed in memory at increasing addresses, the</span><span>
</span><span id="line-504"></span><span class="hs-comment">-- bit pattern is correct for the host's word size and endianness.</span><span>
</span><span id="line-505"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mkLitI"><span class="hs-identifier hs-type">mkLitI</span></a></span><span>   </span><span class="hs-glyph">::</span><span>             </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-506"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mkLitF"><span class="hs-identifier hs-type">mkLitF</span></a></span><span>   </span><span class="hs-glyph">::</span><span>             </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-507"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mkLitD"><span class="hs-identifier hs-type">mkLitD</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-508"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#mkLitI64"><span class="hs-identifier hs-type">mkLitI64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Platform.html#Platform"><span class="hs-identifier hs-type">Platform</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-509"></span><span>
</span><span id="line-510"></span><span id="mkLitF"><span class="annot"><span class="annottext">mkLitF :: Float -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitF"><span class="hs-identifier hs-var hs-var">mkLitF</span></a></span></span><span> </span><span id="local-6989586621681068071"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068071"><span class="hs-identifier hs-var">f</span></a></span></span><span>
</span><span id="line-511"></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [Word]) -&gt; [Word]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-512"></span><span>        </span><span id="local-6989586621681068053"><span class="annot"><span class="annottext">STUArray s Int Float
</span><a href="#local-6989586621681068053"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int Float)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#newArray_"><span class="hs-identifier hs-var">newArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-513"></span><span>        </span><span class="annot"><span class="annottext">STUArray s Int Float -&gt; Int -&gt; Float -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Float
</span><a href="#local-6989586621681068053"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621681068071"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-514"></span><span>        </span><span id="local-6989586621681068050"><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068050"><span class="hs-identifier hs-var">f_arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Float -&gt; ST s (STUArray s Int Word)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Float
</span><a href="#local-6989586621681068053"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-515"></span><span>        </span><span id="local-6989586621681068049"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068049"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068050"><span class="hs-identifier hs-var">f_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-516"></span><span>        </span><span class="annot"><span class="annottext">[Word] -&gt; ST s [Word]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068049"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-517"></span><span>     </span><span class="hs-special">)</span><span>
</span><span id="line-518"></span><span>
</span><span id="line-519"></span><span id="mkLitD"><span class="annot"><span class="annottext">mkLitD :: Platform -&gt; Double -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitD"><span class="hs-identifier hs-var hs-var">mkLitD</span></a></span></span><span> </span><span id="local-6989586621681068047"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068047"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068046"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068046"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#platformWordSize"><span class="hs-identifier hs-var hs-var">platformWordSize</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068047"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-520"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW4"><span class="hs-identifier hs-var">PW4</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [Word]) -&gt; [Word]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-521"></span><span>        </span><span id="local-6989586621681068026"><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068026"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int Double)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#newArray_"><span class="hs-identifier hs-var">newArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-522"></span><span>        </span><span class="annot"><span class="annottext">STUArray s Int Double -&gt; Int -&gt; Double -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068026"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068046"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-523"></span><span>        </span><span id="local-6989586621681068025"><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068025"><span class="hs-identifier hs-var">d_arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double -&gt; ST s (STUArray s Int Word)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068026"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-524"></span><span>        </span><span id="local-6989586621681068024"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068024"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068025"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-525"></span><span>        </span><span id="local-6989586621681068023"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068023"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068025"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-526"></span><span>        </span><span class="annot"><span class="annottext">[Word] -&gt; ST s [Word]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068024"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068023"><span class="hs-identifier hs-var">w1</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-527"></span><span>     </span><span class="hs-special">)</span><span>
</span><span id="line-528"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW8"><span class="hs-identifier hs-var">PW8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [Word]) -&gt; [Word]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-529"></span><span>        </span><span id="local-6989586621681068008"><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068008"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int Double)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#newArray_"><span class="hs-identifier hs-var">newArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-530"></span><span>        </span><span class="annot"><span class="annottext">STUArray s Int Double -&gt; Int -&gt; Double -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068008"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621681068046"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-531"></span><span>        </span><span id="local-6989586621681068007"><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068007"><span class="hs-identifier hs-var">d_arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double -&gt; ST s (STUArray s Int Word)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Double
</span><a href="#local-6989586621681068008"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-532"></span><span>        </span><span id="local-6989586621681068006"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068006"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681068007"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-533"></span><span>        </span><span class="annot"><span class="annottext">[Word] -&gt; ST s [Word]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681068006"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-534"></span><span>     </span><span class="hs-special">)</span><span>
</span><span id="line-535"></span><span>
</span><span id="line-536"></span><span id="mkLitI64"><span class="annot"><span class="annottext">mkLitI64 :: Platform -&gt; Int64 -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitI64"><span class="hs-identifier hs-var hs-var">mkLitI64</span></a></span></span><span> </span><span id="local-6989586621681068005"><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068005"><span class="hs-identifier hs-var">platform</span></a></span></span><span> </span><span id="local-6989586621681068004"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621681068004"><span class="hs-identifier hs-var">ii</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Platform -&gt; PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#platformWordSize"><span class="hs-identifier hs-var hs-var">platformWordSize</span></a></span><span> </span><span class="annot"><span class="annottext">Platform
</span><a href="#local-6989586621681068005"><span class="hs-identifier hs-var">platform</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-537"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW4"><span class="hs-identifier hs-var">PW4</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [Word]) -&gt; [Word]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-538"></span><span>        </span><span id="local-6989586621681067984"><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067984"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int Int64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#newArray_"><span class="hs-identifier hs-var">newArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-539"></span><span>        </span><span class="annot"><span class="annottext">STUArray s Int Int64 -&gt; Int -&gt; Int64 -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067984"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621681068004"><span class="hs-identifier hs-var">ii</span></a></span><span>
</span><span id="line-540"></span><span>        </span><span id="local-6989586621681067983"><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681067983"><span class="hs-identifier hs-var">d_arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64 -&gt; ST s (STUArray s Int Word)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067984"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-541"></span><span>        </span><span id="local-6989586621681067982"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067982"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681067983"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-542"></span><span>        </span><span id="local-6989586621681067981"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067981"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681067983"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-543"></span><span>        </span><span class="annot"><span class="annottext">[Word] -&gt; ST s [Word]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067982"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067981"><span class="hs-identifier hs-var">w1</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-544"></span><span>     </span><span class="hs-special">)</span><span>
</span><span id="line-545"></span><span>   </span><span class="annot"><span class="annottext">PlatformWordSize
</span><a href="../../ghc-boot/src/GHC.Platform.html#PW8"><span class="hs-identifier hs-var">PW8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [Word]) -&gt; [Word]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-546"></span><span>        </span><span id="local-6989586621681067966"><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067966"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int Int64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#newArray_"><span class="hs-identifier hs-var">newArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-547"></span><span>        </span><span class="annot"><span class="annottext">STUArray s Int Int64 -&gt; Int -&gt; Int64 -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067966"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621681068004"><span class="hs-identifier hs-var">ii</span></a></span><span>
</span><span id="line-548"></span><span>        </span><span id="local-6989586621681067965"><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681067965"><span class="hs-identifier hs-var">d_arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64 -&gt; ST s (STUArray s Int Word)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="../../array/src/Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Int64
</span><a href="#local-6989586621681067966"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-549"></span><span>        </span><span id="local-6989586621681067964"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067964"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word -&gt; Int -&gt; ST s Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray s Int Word
</span><a href="#local-6989586621681067965"><span class="hs-identifier hs-var">d_arr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-550"></span><span>        </span><span class="annot"><span class="annottext">[Word] -&gt; ST s [Word]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621681067964"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-551"></span><span>     </span><span class="hs-special">)</span><span>
</span><span id="line-552"></span><span>
</span><span id="line-553"></span><span id="mkLitI"><span class="annot"><span class="annottext">mkLitI :: Int -&gt; [Word]
</span><a href="GHC.ByteCode.Asm.html#mkLitI"><span class="hs-identifier hs-var hs-var">mkLitI</span></a></span></span><span> </span><span id="local-6989586621681067963"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681067963"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int -&gt; Word
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621681067963"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">]</span><span>
</span><span id="line-554"></span><span>
</span><span id="line-555"></span><span class="annot"><a href="GHC.ByteCode.Asm.html#iNTERP_STACK_CHECK_THRESH"><span class="hs-identifier hs-type">iNTERP_STACK_CHECK_THRESH</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-556"></span><span id="iNTERP_STACK_CHECK_THRESH"><span class="annot"><span class="annottext">iNTERP_STACK_CHECK_THRESH :: Int
</span><a href="GHC.ByteCode.Asm.html#iNTERP_STACK_CHECK_THRESH"><span class="hs-identifier hs-var hs-var">iNTERP_STACK_CHECK_THRESH</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">INTERP_STACK_CHECK_THRESH</span><span>
</span><span id="line-557"></span></pre></body></html>